Slik scraper jeg Amazon-anmeldelser med Python (forbi innloggingsveggen)

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 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 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 (og aldri la det tilbake), er nettscraping den eneste programatiske veien til disse dataene.

Tallene støtter dette. , og . Å vise bare 5 anmeldelser på en produktside kan . Selskaper som systematisk analyserer sentiment i anmeldelser ser . 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 , 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:

Et kjøkkenutstyrmerke , endret oppskriften på produktet og tok tilbake sin plass som #1 Best Seller innen 60 dager. Et selskap som lager aktivitetstrackere , 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

14. november 2024 . Endringen ble bekreftet i både og . 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 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:

1pip install requests beautifulsoup4 lxml pandas textblob

Valgfritt (for avansert sentimentanalyse):

1pip 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:

Slik henter du ut cookies fra Chrome DevTools

1. Logg inn på amazon.com i Chrome
2. Åpne DevTools (F12 eller høyreklikk → Inspiser)
3. Gå til Application → Storage → Cookies → https://www.amazon.com
4. Finn hvert cookie-navn i tabellen og kopier verdien
5. Formater dem som en streng med semikolon mellom verdiene for Python

Sett opp sesjonen slik:

1import requests
2session = requests.Session()
3# Lim inn cookie-verdiene dine her
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)

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:

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

Kjernefunksjonen:

1from bs4 import BeautifulSoup
2import time, random
3def get_soup(session, url):
4    time.sleep(random.uniform(2, 5))  # Høflig pause
5    response = session.get(url, timeout=15)
6    # Oppdag innloggingsveggen
7    if "ap_email" in response.text or "Amazon Sign-In" in response.text:
8        raise Exception("Innloggingsvegg oppdaget — oppdater cookie-ene dine")
9    if response.status_code != 200:
10        raise Exception(f"HTTP {response.status_code}")
11    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.

1# Besøk produktsiden først (etterligner vanlig nettlesing)
2product_url = f"https://www.amazon.com/dp/{asin}"
3session.get(product_url, timeout=15)
4time.sleep(random.uniform(1, 3))
5# Så går du til anmeldelsessiden
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: 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.

Uthentingskoden 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        # Stjernerating
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        # Tittel
15        title_el = div.select_one('[data-hook="review-title"]')
16        title = title_el.get_text(strip=True) if title_el else ""
17        # Brødtekst
18        body_el = div.select_one('[data-hook="review-body"]')
19        body = body_el.get_text(strip=True) if body_el else ""
20        # Forfatter
21        author_el = div.select_one('span.a-profile-name')
22        author = author_el.get_text(strip=True) if author_el else ""
23        # Dato og 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        # Verifisert kjø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

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:

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  # Ingen flere anmeldelser på denne siden
8    all_reviews.extend(page_reviews)
9    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.

1star_filters = ["one_star", "two_star", "three_star", "four_star", "five_star"]
2sort_orders = ["recent", "helpful"]
3all_reviews = []
4seen_titles = set()  # Enkel deduplisering
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                # Dedupliser ved å bruke tittel + forfatter som nøkkel
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}] Side {page}: {len(page_reviews)} anmeldelser")
23print(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.

En retry-wrapper klar for produksjon:

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            # Oppdag blokkeringer
16            if "validateCaptcha" in response.url or "Robot Check" in response.text:
17                wait = (2 ** attempt) * 5
18                print(f"CAPTCHA oppdaget. Venter {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}). Venter {wait}s...")
24                time.sleep(wait)
25                continue
26            if "ap_email" in response.text:
27                raise Exception("Innloggingsvegg — cookie-ene har utløpt")
28            return BeautifulSoup(response.text, "lxml")
29        except Exception as e:
30            if attempt == max_retries - 1:
31                raise
32            print(f"Forsøk {attempt + 1} mislyktes: {e}")
33    return None

Et notat om proxies: Amazon (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 . 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:

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

Eksempel på utdata:

For Excel-eksport: df.to_excel("amazon_reviews.xlsx", index=False) (krever openpyxl).

For Google Sheets fungerer gspread-biblioteket, men det krever — 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 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:

1from textblob import TextBlob
2df["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:

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. , og sammenlignet med ordlistebaserte verktøy. Modellen nlptown/bert-base-multilingual-uncased-sentiment kan til og med forutsi 1–5 stjerner direkte:

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-anmeldelser følger en — 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:

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 for å håndtere akkurat de situasjonene der det føles som overkill å vedlikeholde en Python-scraper. Arbeidsflyten ser slik ut:

1. Installer
2. Gå til anmeldelsessiden for Amazon-produktet i nettleseren din (du er allerede logget inn, så innloggingsveggen er ikke et problem)
3. Klikk "AI Suggest Fields" — Thunderbit leser siden og foreslår kolonner som Forfatter, Rating, Tittel, Anmeldelsestekst, Dato, Verifisert kjøp
4. Klikk "Scrape" — dataene hentes umiddelbart, med innebygd paginering
5. Eksporter til Excel, Google Sheets, Airtable eller Notion

Hovedfordelen er at Thunderbits AI leser side­strukturen 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 — strukturert datauthenting via API med AI-drevet feltgjenkjenning, uten vedlikehold av selektorer.

For dypere guider om Amazon-data, se våre artikler om og .

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:

1import sqlite3
2conn = sqlite3.connect("reviews.db")
3df.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 og flere alternativer.

En kort merknad om juridiske og etiske hensyn

Amazons 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 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 .

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.

håndterer autentisering, selektorer, paginering og eksport med noen få klikk — prøv 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 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 .

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