Min Amazon-anmeldelsesscraper fungerte knirkefritt i seks uker — så en morgen fikk jeg 200 OK og en side full av ingenting. Ingen feil, ingen CAPTCHA, bare tom HTML der hundrevis av anmeldelser pleide å ligge.
Hvis det høres kjent ut, er du ikke alene. Sent i 2025 begynte Amazon å legge hele anmeldelsessidene bak en innloggingsvegg, og et stort antall Python-skript sluttet å virke over natten. Jeg har brukt de siste månedene hos Thunderbit på å jobbe med problemet fra begge sider — både ved å bygge AI-scraperen vår og ved å vedlikeholde min egen Python-pipeline for anmeldelser — så jeg tenkte det var på tide å skrive guiden jeg selv skulle ønske jeg hadde hatt da skriptet mitt først døde. Dette innlegget tar for seg metoden som faktisk fungerer: cookie-basert autentisering, stabile selektorer som tåler Amazons CSS-obfuskering, løsninger for 10-siders pagineringsgrensen, anti-bot-forsvar, og som bonus en del om sentimentanalyse som gjør rå anmeldelsestekst om til reell forretningsinnsikt. Og hvis du halvveis tenker: «Jeg vil egentlig ikke vedlikeholde all denne koden», skal jeg vise deg hvordan Thunderbit løser samme jobb på omtrent to minutter uten Python.
Hva er Amazon-anmeldelsesscraping, og hvorfor er det viktig?
Amazon-anmeldelsesscraping er prosessen med å hente ut kundevurderinger programmatisk — stjernerating, anmeldelsestekst, forfatternavn, datoer, merker for verifisert kjøp — fra Amazon-produktsider. Siden Amazon fjernet anmeldelsesinnhold fra Product Advertising API-et sitt allerede i 2010 (og aldri la det tilbake), er nettscraping den eneste programatiske veien til disse dataene.
Tallene støtter dette. 95 % av kundene leser anmeldelser før de kjøper, og 94 % oppgir Amazon som sin viktigste kilde til produktanmeldelser. Å vise bare 5 anmeldelser på en produktside kan øke konverteringen med 270 %. Selskaper som systematisk analyserer sentiment i anmeldelser ser opptil 15 % høyere kundelojalitet. Dette er ikke abstrakt datavitenskap — det er konkurranseinnsikt, signaler for produktforbedring og markedsføringsspråk, alt sammen tilgjengelig i ren tekst på Amazons servere.
Hvorfor scrape Amazon-anmeldelser med Python
Python er fortsatt førstevalget for denne typen arbeid. Det er det mest ettertraktede språket i Stack Overflow Developer Survey 2024, og økosystemet — requests, BeautifulSoup, pandas, Scrapy — gjør nettscraping tilgjengelig selv for folk som ikke jobber som utviklere på heltid.
Forskjellige team bruker disse dataene på ulike måter:
| Team | Bruksområde | Hva de henter ut |
|---|---|---|
| Produkt / FoU | Identifisere gjentakende klager, prioritere forbedringer | 1–2-stjerners anmeldelsestekst, nøkkelordfrekvens |
| Salg | Overvåke sentiment på konkurrenters produkter | Vurderinger, volumtrender for anmeldelser |
| Markedsføring | Finne kundespråk til annonsetekster | Positive formuleringer fra anmeldelser, omtale av funksjoner |
| E-handel / drift | Følge sentiment rundt egne produkter over tid | Fordeling av stjerner, andel verifiserte kjøp |
| Markedsanalyse | Sammenligne kategori-ledere på tvers av funksjoner | Anmeldelsesdatasett for flere ASIN-er |
Et kjøkkenutstyrmerke sanket negative anmeldelser, fant at 22 % nevnte at «non-stick-belegget slites av», endret oppskriften på produktet og tok tilbake sin plass som #1 Best Seller innen 60 dager. Et selskap som lager aktivitetstrackere oppdaget «irritasjon fra remmen» i anmeldelsestekst, identifiserte et problem med lateksallergi, lanserte en hypoallergen variant og reduserte returene med 40 %. Det er denne typen ROI som gjør den tekniske innsatsen verdt det.
Innloggingsvegg: Hvorfor Amazon-anmeldelsesscraperen din sluttet å virke
- november 2024 begynte Amazon å kreve innlogging for å vise hele anmeldelsessiden for produkter. Endringen ble bekreftet i både community-forum og blogger fra scraping-leverandører. Hvis du besøker
/product-reviews/{ASIN}/i et inkognitovindu, blir du videresendt til en innloggingsside i stedet for anmeldelsesdata.
Symptomene er subtile: skriptet ditt får et 200 OK-svar, men HTML-bodyen inneholder et innloggingsskjema (name="email", id="ap_password") i stedet for anmeldelser. Ingen feilkode. Ingen CAPTCHA. Bare ... ingenting nyttig.
Amazon gjorde dette av hensyn til anti-bot og regional samsvar. Håndhevingen er inkonsekvent — noen ganger laster et nytt nettleservindu inn noen få anmeldelser før veggen slår inn, spesielt på første side — men for enhver scraper som skal kjøre i skala, bør du regne med at veggen alltid er aktiv.
Ulike Amazon-domener for land (.de, .co.uk, .co.jp) håndhever dette separat. Som en bruker på et forum formulerte det: «du trenger innlogging for hvert land». Cookie-ene fra .com fungerer ikke på .co.uk.
Utvalgte anmeldelser vs. fullstendige anmeldelser: Hva du fortsatt kan se uten innlogging
Amazon-produktsidene (/dp/{ASIN}/) viser fortsatt omtrent 8 «utvalgte anmeldelser» uten autentisering. Disse er håndplukket av Amazons algoritme og er nyttige for en rask sjekk av sentiment, men de kan ikke sorteres, filtreres eller pagineres.
De fullstendige anmeldelsessidene (/product-reviews/{ASIN}/) — med sortering etter nyeste, filtrering på stjerner og paginering gjennom hundrevis av anmeldelser — krever innlogging.
Hvis du bare trenger noen få anmeldelser for en kjapp status, kan du scrape produktsiden. For hundrevis eller tusenvis må du håndtere autentisering.
Dette trenger du før du begynner: Python-oppsett og biblioteker
Før vi skriver kode, her er oppsettet:
- Vanskelighetsgrad: Middels (du bør være komfortabel med Python og ha grunnleggende HTML-forståelse)
- Tidsbruk: Rundt 45 minutter for hele pipelinen; rundt 10 minutter for en enkel scrape
- Det du trenger: Python 3.8+, Chrome-nettleser, en gyldig Amazon-konto
Installer kjernebibliotekene:
pip install requests beautifulsoup4 lxml pandas textblob
Valgfritt (for avansert sentimentanalyse):
pip install transformers torch
Hva er en ASIN? Det er Amazons 10-tegns produktidentifikator. Du finner den i enhver produkt-URL — for eksempel i amazon.com/dp/B0BCNKKZ91 er ASIN-en B0BCNKKZ91. Det er nøkkelen du bruker i anmeldelses-URL-en.
Steg 1: Kom forbi innloggingsveggen med cookie-basert autentisering
Den mest pålitelige metoden er å logge inn på Amazon i nettleseren din, kopiere sesjons-cookie-ene og injisere dem i Python requests.Session(). Dette unngår CAPTCHA-er og SMS-basert tofaktorautentisering som ofte ødelegger Selenium-baserte innloggingsløsninger.
Du trenger disse syv cookie-ene:
| Cookie-navn | Formål |
|---|---|
session-id | Roterende sesjonsidentifikator |
session-id-time | Tidsstempel for sesjonen |
session-token | Roterende sesjonstoken |
ubid-main | Identifikator for brukerens nettlesing |
at-main | Primært autentiseringstoken |
sess-at-main | Sesjonsbasert autentisering |
x-main | Identifikator knyttet til brukerens e-post |
Slik henter du ut cookies fra Chrome DevTools
- Logg inn på amazon.com i Chrome
- Åpne DevTools (F12 eller høyreklikk → Inspiser)
- Gå til Application → Storage → Cookies →
https://www.amazon.com - Finn hvert cookie-navn i tabellen og kopier verdien
- Formater dem som en streng med semikolon mellom verdiene for Python
Sett opp sesjonen slik:
import requests
session = requests.Session()
# Lim inn cookie-verdiene dine her
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)
Viktig: Bruk samme session-objekt for alle forespørsler. Det holder cookie-ene konsistente og etterligner en ekte nettlesersesjon. Cookie-er varer vanligvis fra noen dager til noen uker under scraping-belastning, men hvis du igjen begynner å bli sendt til innlogging, må du hente dem på nytt fra nettleseren.
For markedsplasser utenfor .com endrer cookie-navnene seg litt — amazon.de bruker at-acbde i stedet for at-main, amazon.co.uk bruker at-acbuk, og så videre. Hver markedsplass trenger sin egen separate sesjon.
Steg 2: Bygg forespørselen og parse anmeldelses-HTML med BeautifulSoup
Amazon-URL-en for anmeldelser følger dette mønsteret:
https://www.amazon.com/product-reviews/{ASIN}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber=1
Kjernefunksjonen:
from bs4 import BeautifulSoup
import time, random
def get_soup(session, url):
time.sleep(random.uniform(2, 5)) # Høflig pause
response = session.get(url, timeout=15)
# Oppdag innloggingsveggen
if "ap_email" in response.text or "Amazon Sign-In" in response.text:
raise Exception("Innloggingsvegg oppdaget — oppdater cookie-ene dine")
if response.status_code != 200:
raise Exception(f"HTTP {response.status_code}")
return BeautifulSoup(response.text, "lxml")
Et lite triks som hjelper: før du går til anmeldelsessiden, besøk produktsiden først. Det gir en mer naturlig nettlesingsflyt i sesjonen din.
# Besøk produktsiden først (etterligner vanlig nettlesing)
product_url = f"https://www.amazon.com/dp/{asin}"
session.get(product_url, timeout=15)
time.sleep(random.uniform(1, 3))
# Så går du til anmeldelsessiden
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)
Steg 3: Bruk stabile selektorer for å hente ut anmeldelsesdata (slutt å stole på CSS-klasser)
Det er her de fleste veiledninger fra 2022–2023 faller sammen. Amazon obfuskere CSS-klassenavn — de endres med jevne mellomrom, og som en frustrert utvikler skrev i et foruminnlegg: «ingen av dem hadde et eneste mønster for navnene på klasse-tagene til span-taggene.»
Løsningen: Amazon bruker data-hook-attributter på anmeldelseselementer, og disse er overraskende stabile. De er semantiske identifikatorer som Amazons egen frontend-kode er avhengig av, så de blir ikke randomisert.
| Anmeldelsesfelt | Stabil selektor (data-hook) | Sårbar selektor (klasse) |
|---|---|---|
| Anmeldelsestekst | [data-hook="review-body"] | .review-text-content (endres) |
| Stjernerating | [data-hook="review-star-rating"] | .a-icon-alt (uklar) |
| Anmeldelsestittel | [data-hook="review-title"] | .review-title (noen ganger) |
| Forfatternavn | span.a-profile-name | Relativt stabil |
| Anmeldelsesdato | [data-hook="review-date"] | .review-date (regionsavhengig) |
| Verifisert kjøp | [data-hook="avp-badge"] | span.a-size-mini |
Uthentingskoden med data-hook-selektorer:
import re
def extract_reviews(soup):
reviews = []
review_divs = soup.select('[data-hook="review"]')
for div in review_divs:
# Stjernerating
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))
# Tittel
title_el = div.select_one('[data-hook="review-title"]')
title = title_el.get_text(strip=True) if title_el else ""
# Brødtekst
body_el = div.select_one('[data-hook="review-body"]')
body = body_el.get_text(strip=True) if body_el else ""
# Forfatter
author_el = div.select_one('span.a-profile-name')
author = author_el.get_text(strip=True) if author_el else ""
# Dato og land
date_el = div.select_one('[data-hook="review-date"]')
date_text = date_el.get_text(strip=True) if date_el else ""
# Format: "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 ""
# Verifisert kjøp
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
Jeg har kjørt dette selektor-settet mot flere ASIN-er i månedsvis nå, og data-hook-attributtene har ikke endret seg en eneste gang. CSS-klassene derimot har rotert minst to ganger i samme periode.
Steg 4: Håndter paginering og Amazons 10-sidersgrense
Amazon begrenser pageNumber-parameteren til 10 sider med 10 anmeldelser per side — et hardt tak på omtrent 100 anmeldelser per filterkombinasjon. «Neste side»-knappen forsvinner ganske enkelt etter side 10.
Grunnleggende pagineringsløkke:
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 # Ingen flere anmeldelser på denne siden
all_reviews.extend(page_reviews)
print(f"Side {page}: {len(page_reviews)} anmeldelser")
Slik får du mer enn 10 sider med Amazon-anmeldelser
Løsningen er filter-bucketing. Hver kombinasjon av filterByStar og sortBy får sitt eget uavhengige 10-sidersvindu.
Stjernefilter-verdier: one_star, two_star, three_star, four_star, five_star
Sorteringsverdier: recent, helpful (standard)
Ved å kombinere alle 5 stjernefilterne × 2 sorteringsrekkefølger kan du få tilgang til opptil 100 sider, 1 000 anmeldelser per produkt — og for produkter med ujevn fordeling av stjerner kommer du ofte ganske nær hele anmeldelsessettet.
star_filters = ["one_star", "two_star", "three_star", "four_star", "five_star"]
sort_orders = ["recent", "helpful"]
all_reviews = []
seen_titles = set() # Enkel deduplisering
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:
# Dedupliser ved å bruke tittel + forfatter som nøkkel
key = (review["title"], review["author"])
if key not in seen_titles:
seen_titles.add(key)
all_reviews.append(review)
print(f"[{star}/{sort}] Side {page}: {len(page_reviews)} anmeldelser")
print(f"Totalt antall unike anmeldelser: {len(all_reviews)}")
Det blir overlapp mellom bøttene, så deduplisering er viktig. Jeg bruker en kombinasjon av anmeldelsestittel + forfatternavn som en rask nøkkel — ikke perfekt, men det fanger opp langt de fleste duplikater.
Steg 5: Unngå anti-bot-forsvar (roter, throttling, retry)
Amazon bruker AWS WAF Bot Control, og det har blitt betydelig mer aggressivt. Én enkel mottiltakslinje (bare rotere User-Agent, bare legge inn forsinkelser) holder ikke lenger.
| Teknikk | Implementering |
|---|---|
| Rotering av User-Agent | Tilfeldig valg fra 10+ ekte nettleserstrenger |
| Eksponentiell backoff | 2s → 4s → 8s ventetid ved 503-feil |
| Forespørselstakting | random.uniform(2, 5) sekunder mellom sider |
| Proxy-rotasjon | Sirkuler gjennom residential proxies |
| Sesjonsfingeravtrykk | Konsistente cookies + headers per sesjon |
| TLS-etterligning | Bruk curl_cffi i stedet for standard requests i produksjon |
En retry-wrapper klar for produksjon:
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)
# Oppdag blokkeringer
if "validateCaptcha" in response.url or "Robot Check" in response.text:
wait = (2 ** attempt) * 5
print(f"CAPTCHA oppdaget. Venter {wait}s...")
time.sleep(wait)
continue
if response.status_code in (429, 503):
wait = (2 ** attempt) * 2
print(f"Rate limit ({response.status_code}). Venter {wait}s...")
time.sleep(wait)
continue
if "ap_email" in response.text:
raise Exception("Innloggingsvegg — cookie-ene har utløpt")
return BeautifulSoup(response.text, "lxml")
except Exception as e:
if attempt == max_retries - 1:
raise
print(f"Forsøk {attempt + 1} mislyktes: {e}")
return None
Et notat om proxies: Amazon blokkerer kjente datasenter-IP-områder (AWS, GCP, Azure, DigitalOcean) på nettverksnivå. Hvis du scraper mer enn noen få hundre sider, er residential proxies i praksis et must — regn med å bruke 50–200+ USD i måneden avhengig av volum. For mindre prosjekter (under 100 forespørsler per dag) fungerer ofte forsiktig throttling fra egen IP helt fint.
Amazon sjekker også TLS-fingeravtrykk. Python sitt standard requests-bibliotek har en velkjent JA3-hash som WAF-er ofte blokkerer på forhånd. For produksjonsscrapere bør du vurdere curl_cffi, som etterligner ekte nettleser-TLS-stakker. For tutorial-nivå scraping (noen hundre sider) kommer du som regel langt med requests og gode headers.
Steg 6: Eksporter Amazon-anmeldelsene dine til CSV eller Excel
Når du har samlet anmeldelsene, er det enkelt å få dem inn i et brukbart format med pandas:
import pandas as pd
df = pd.DataFrame(all_reviews)
df.to_csv("amazon_reviews.csv", index=False)
print(f"Eksporterte {len(df)} anmeldelser til amazon_reviews.csv")
Eksempel på utdata:
| author | rating | title | content | date | country | verified |
|---|---|---|---|---|---|---|
| Sarah M. | 5.0 | Best purchase this year | Battery lasts all day, screen is gorgeous... | January 15, 2025 | the United States | True |
| Mike T. | 2.0 | Disappointed after 2 weeks | The charging port stopped working... | February 3, 2025 | the United States | True |
| Priya K. | 4.0 | Great value for the price | Does everything I need, minor lag on heavy apps... | March 10, 2025 | the United States | False |
For Excel-eksport: df.to_excel("amazon_reviews.xlsx", index=False) (krever openpyxl).
For Google Sheets fungerer gspread-biblioteket, men det krever 8+ steg med Google Cloud-oppsett — opprette et prosjekt, aktivere to API-er, generere service account-legitimasjon, dele arket. Hvis det høres ut som mer oppsett enn selve scrapingen, tar du ikke feil. (Dette er en av de situasjonene der et verktøy som Thunderbit som eksporterer til Google Sheets med ett klikk plutselig ser veldig attraktivt ut.)
Bonus: Legg til sentimentanalyse på de scraped anmeldelsene dine med 5 linjer Python
De fleste scraping-guider stopper ved CSV-eksport. Men sentiment-scoring er det som gjør rå data om til forretningsbeslutninger.
Den raskeste basisløsningen bruker TextBlob:
from textblob import TextBlob
df["sentiment"] = df["content"].apply(lambda x: TextBlob(str(x)).sentiment.polarity)
Det gir deg en polaritetsscore fra -1.0 (svært negativ) til +1.0 (svært positiv) for hver anmeldelse. Eksempel på utdata:
| content (forkortet) | rating | sentiment |
|---|---|---|
| "Battery lasts all day, screen is gorgeous..." | 5.0 | 0.65 |
| "The charging port stopped working after..." | 2.0 | -0.40 |
| "Does everything I need, minor lag on..." | 4.0 | 0.25 |
| "Absolute garbage. Returned immediately." | 1.0 | -0.75 |
| "It's okay. Nothing special but works." | 3.0 | 0.10 |
De interessante radene er avvikene — en 3-stjerners anmeldelse med positiv tekst, eller en 5-stjerners anmeldelse med negativt språk. Slike forskjeller avslører ofte nyanserte kundeopplevelser som stjernerating alene ikke fanger opp.
For produksjonsklar nøyaktighet anbefales Hugging Face Transformers. VADER ble trent på tweets, ikke produktanmeldelser, og transformermodeller oppnår over 98 % nøyaktighet på klassifisering av anmeldelser sammenlignet med ordlistebaserte verktøy. Modellen nlptown/bert-base-multilingual-uncased-sentiment kan til og med forutsi 1–5 stjerner direkte:
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])
)
Amazon-anmeldelser følger en J-formet fordeling — en stor topp på 5 stjerner, en mindre topp på 1 stjerne, og en dal i midten. Det betyr at gjennomsnittlig stjernerating ofte er en dårlig proxy for faktisk produktkvalitet. Segmenter 1-stjernersklyngen og let etter gjentakende temaer — det er som regel der du finner en enkelt feil som faktisk kan fikses.
Den ærlige avveiningen: DIY Python vs. betalte scraping-API-er vs. Thunderbit
Jeg har vedlikeholdt Python-scrapere for Amazon, og jeg skal være ærlig: de går i stykker. Selektorer endres, cookies utløper, Amazon lanserer et nytt bot-deteksjonslag, og plutselig går lørdagsmorgenen med til å feilsøke en scraper i stedet for å analysere data. Forumbrukere rapporterer den samme frustrasjonen — DIY-skript som «fungerte forrige måned» trenger nå konstant lapping.
Slik står de tre hovedtilnærmingene mot hverandre:
| Kriterium | DIY Python (BS4/Selenium) | Betalt scraping-API | Thunderbit (No-code) |
|---|---|---|---|
| Oppsetttid | 1–3 timer | 30 min (API-nøkkel) | 2 minutter |
| Kostnad | Gratis (+ proxy-kostnader) | 50–200+ USD/mnd | Gratis nivå tilgjengelig |
| Håndtering av innloggingsvegg | Manuell cookie-håndtering | Vanligvis håndtert | Håndteres automatisk |
| Vedlikehold | Høyt (selektorer bryter) | Lavt (leverandøren vedlikeholder) | Ingen (AI tilpasser seg) |
| Paginering | Egen kode kreves | Innebygd | Innebygd |
| Støtte for flere land | Separate sesjoner per domene | Vanligvis støttet | Nettleserbasert = din locale |
| Sentimentanalyse | Legg til egen kode | Noen ganger inkludert | Eksporter til Sheets, analyser hvor som helst |
| Best for | Læring, full kontroll | Skalering/produksjonspipelines | Rask datauthenting, team uten utviklere |
Python gir deg full kontroll og er faktisk den beste måten å lære hvordan nettscraping fungerer under panseret. Betalte API-er (ScrapingBee, Oxylabs, Bright Data) gir mening for produksjonspipelines der oppetid er viktigere enn kostnad. Og for team som trenger anmeldelsesdata uten utviklerbelastningen — e-handelsdrift som følger konkurrenter ukentlig, markedsføringsteam som henter kundespråk til annonsetekster — finnes det en tredje vei.
Slik scraper du Amazon-anmeldelser med Thunderbit (uten kode, uten vedlikehold)
Vi bygde Thunderbit for å håndtere akkurat de situasjonene der det føles som overkill å vedlikeholde en Python-scraper. Arbeidsflyten ser slik ut:
- Installer Thunderbit Chrome-utvidelsen
- Gå til anmeldelsessiden for Amazon-produktet i nettleseren din (du er allerede logget inn, så innloggingsveggen er ikke et problem)
- Klikk "AI Suggest Fields" — Thunderbit leser siden og foreslår kolonner som Forfatter, Rating, Tittel, Anmeldelsestekst, Dato, Verifisert kjøp
- Klikk "Scrape" — dataene hentes umiddelbart, med innebygd paginering
- Eksporter til Excel, Google Sheets, Airtable eller Notion
Hovedfordelen er at Thunderbits AI leser sidestrukturen på nytt hver gang. Ingen CSS-selektorer å vedlikeholde, ingen cookie-håndtering, ingen anti-bot-kode. Når Amazon endrer HTML-en sin, tilpasser AI-en seg. For lesere som ønsker programmatisk tilgang uten full DIY, tilbyr Thunderbit også en Extract API — strukturert datauthenting via API med AI-drevet feltgjenkjenning, uten vedlikehold av selektorer.
For dypere guider om Amazon-data, se våre artikler om hvordan du scraper Amazon-produkter og -anmeldelser og å hente ut og analysere Amazon-salgsdata.
Tips for å scrape Amazon-anmeldelser i stor skala med Python
Hvis du scraper anmeldelser på tvers av mange ASIN-er, er det noen vaner som sparer deg for mye hodebry:
- Batch ASIN-ene dine med pauser mellom produktene, ikke bare mellom sidene. Jeg bruker 10–15 sekunders pauser mellom ASIN-er.
- Dedupliser aggressivt. Når du kombinerer flere stjernefiltre og sorteringsrekkefølger, får du overlappende anmeldelser. Bruk et sett med
(title, author, date)som dedupliseringsnøkkel. - Logg feil. Spor hvilke ASIN + side + filter-kombinasjoner som feilet, så du kan kjøre dem på nytt uten å scrape alt på nytt.
- Lagre i en database for større prosjekter. En enkel SQLite-database skalerer mye bedre enn stadig voksende CSV-filer:
import sqlite3
conn = sqlite3.connect("reviews.db")
df.to_sql("reviews", conn, if_exists="append", index=False)
- Planlegg gjentakende scraping. For løpende overvåking kan du sette opp en cron-jobb eller bruke Thunderbits Scheduled Scraper-funksjon — beskriv URL-en og tidspunktet, så ordner den resten uten server.
For flere tilnærminger dekker innleggene våre om beste automatiserte web scraping-verktøy og å scrape data fra nettsteder til Excel flere alternativer.
En kort merknad om juridiske og etiske hensyn
Amazons vilkår for bruk forbyr eksplisitt «bruk av robot, spider, scraper eller andre automatiserte midler for å få tilgang til Amazon-tjenester». Samtidig har nyere amerikansk rettspraksis vært mer gunstig for scraping av offentlig data. I Meta Platforms v. Bright Data (januar 2024) slo en føderal domstol fast at scraping av offentlig tilgjengelige data ikke bryter vilkårene når scraperen ikke er en innlogget «bruker».
Nyansen er viktig: scraping bak innlogging (som denne guiden handler om) bringer deg inn i kontraktsrettslig terreng, siden du samtykket til Amazons vilkår da du opprettet kontoen din. Å scrape offentlig synlige utvalgte anmeldelser innebærer mindre juridisk risiko enn å scrape bak innloggingsveggen.
Praktiske retningslinjer: ikke videredistribuer scraped data kommersielt, ikke samle inn persondata utover det som er offentlig synlig, respekter robots.txt, og rådfør deg med jurist ved storstilt eller kommersiell bruk. Dette er ikke juridisk rådgivning. For mer om det juridiske landskapet, se vår oversikt over juridiske konsekvenser ved webscraping.
Konklusjon: Scrape Amazon-anmeldelser med Python, eller hopp over koden helt
Kort oppsummert det denne guiden har gått gjennom:
- Innloggingsveggen er reell, men kan løses med cookie-basert autentisering — kopier 7 cookies fra nettleseren din og injiser dem i en
requests.Session() - Bruk
data-hook-selektorer, ikke CSS-klasser, for uthenting som ikke bryter annenhver uke - Kombiner stjernefiltre og sorteringsrekkefølger for å komme forbi 10-sidersgrensen og få tilgang til 500+ anmeldelser per produkt
- Legg til sentimentanalyse med TextBlob for et raskt grunnlag eller Hugging Face Transformers for produksjonsnøyaktighet
- Vedlikehold anti-bot-forsvar: throttling, rotasjon av User-Agent, eksponentiell backoff og residential proxies når du skalerer
Python gir deg full kontroll og er den beste måten å forstå hva som skjer under panseret. Men hvis brukstilfellet ditt er «jeg trenger konkurrentenes anmeldelsesdata i et regneark innen fredag» heller enn «jeg vil bygge en produksjonsklar datapipeline», er kanskje vedlikeholdsbyrden ved en egen scraper ikke verdt det.
Thunderbit håndterer autentisering, selektorer, paginering og eksport med noen få klikk — prøv gratisnivået og se om det passer arbeidsflyten din. Etter hvert som Amazon fortsetter å stramme inn anti-bot-tiltakene, vil AI-drevne verktøy som tilpasser seg i sanntid gå fra å være en «nice to have» til å bli en nødvendighet.
Du kan også utforske vår Thunderbit YouTube-kanal for videoguider som viser scraping-arbeidsflyter.
Vanlige spørsmål
1. Kan man scrape Amazon-anmeldelser uten å logge inn?
Ja, men bare de omtrent 8 «utvalgte anmeldelsene» som vises på produktsiden (/dp/{ASIN}/). De fullstendige anmeldelsessidene med sortering, filtrering og paginering krever autentisering fra slutten av 2024. For de fleste forretningsbehov må du håndtere innloggingsveggen.
2. Er det lov å scrape Amazon-anmeldelser?
Amazons vilkår for bruk forbyr automatisk scraping. Samtidig støtter nyere amerikanske dommer (Meta v. Bright Data, 2024; hiQ v. LinkedIn) scraping av offentlig tilgjengelige data. Å scrape bak innlogging innebærer høyere juridisk risiko siden du har samtykket til Amazons vilkår. Rådfør deg med jurist ved kommersiell bruk.
3. Hvor mange Amazon-anmeldelser kan jeg scrape per produkt?
Amazon begrenser anmeldelsessider til 10 per sorterings- og stjernefilterkombinasjon. Ved å bruke alle 5 stjernefiltre × 2 sorteringsrekkefølger kan du få tilgang til opptil 100 sider (omtrent 1 000 anmeldelser) per produkt. Med nøkkelordsfiltre er det teoretiske taket mye høyere, men med betydelig duplisering.
4. Hva er det beste Python-biblioteket for å scrape Amazon-anmeldelser?
requests + BeautifulSoup for statisk HTML-parsing er den vanligste og mest pålitelige kombinasjonen. Selenium er nyttig når JavaScript-rendering er nødvendig. For et no-code-alternativ som håndterer innloggingsvegger og paginering automatisk, prøv Thunderbit.
5. Hvordan unngår jeg å bli blokkert når jeg scraper Amazon?
Roter User-Agent-strenger fra en pool med 10+ ekte nettleserstrenger, legg inn tilfeldige pauser på 2–5 sekunder mellom forespørsler, implementer eksponentiell backoff ved 503/429-feil, bruk residential proxies når du skalerer (datasenter-IP-er er ofte forhåndsblokkert), og hold cookies konsistente mellom forespørsler. For en vedlikeholdsfri tilnærming håndterer Thunderbit anti-bot-forsvar automatisk gjennom nettlesersesjonen din.
Les mer
