Sådan scraper jeg Amazon-anmeldelser med Python (forbi login-muren)

Min Amazon-anmeldelsesscraper fungerede perfekt i seks uger — og så en morgen returnerede den 200 OK og en side fyldt med ingenting. Ingen fejl, ingen CAPTCHA, bare tom HTML dér, hvor der før lå hundredvis af anmeldelser.

Hvis det lyder bekendt, er du ikke alene. I slutningen af 2025 begyndte Amazon at lægge sine fulde anmeldelsessider bag en login-mur, og et stort antal Python-scripts til scraping gik i stykker fra den ene dag til den anden. Jeg har tilbragt de seneste måneder hos med at arbejde på problemet fra begge sider — både ved at bygge vores AI scraper og ved at vedligeholde min egen Python-pipeline til anmeldelser — så jeg tænkte, at det var tid til at skrive den guide, jeg selv ville ønske, jeg havde haft, da mit script først gik i sort. Indlægget her gennemgår den løsning, der faktisk virker: cookie-baseret autentificering, stabile selektorer, der overlever Amazons CSS-obfuskering, workarounds til grænsen på 10 sider, anti-bot-forsvar og et bonusafsnit om sentimentanalyse, der omsætter rå anmeldelsestekst til reel forretningsindsigt. Og hvis du halvvejs tænker: "Jeg gider egentlig ikke vedligeholde al den kode," så viser jeg også, hvordan klarer det samme på cirka to minutter uden Python.

Hvad er scraping af Amazon-anmeldelser, og hvorfor er det vigtigt?

Scraping af Amazon-anmeldelser er processen, hvor man programmatisk udtrækker kundedata fra anmeldelser — stjerner, anmeldelsestekst, forfatternavne, datoer, badge for verificeret køb og meget mere — fra produktsider på Amazon. Siden Amazon (og aldrig bragte det tilbage), er web scraping den eneste programatiske vej til disse data.

Tallene underbygger det. , og . At vise bare 5 anmeldelser på en produktside kan . Virksomheder, der systematisk analyserer anmeldelsessentiment, ser . Det her er ikke abstrakt data science — det er konkurrenceintelligens, produktfeedback og marketing-sprog, alt sammen skrevet i ren tekst på Amazons servere.

Hvorfor scrape Amazon-anmeldelser med Python

Python er stadig det foretrukne sprog til den her type opgave. Det er , og økosystemet — requests, BeautifulSoup, pandas, Scrapy — gør web scraping tilgængeligt, også for folk der ikke arbejder som udviklere på fuld tid.

Forskellige teams bruger dataene på forskellige måder:

Et køkkenvarebrand , reformulerede produktet og genvandt sin placering som #1 Best Seller inden for 60 dage. En virksomhed bag en fitness tracker , identificerede et latexallergi-problem, lancerede en allergivenlig variant og reducerede returneringer med 40%. Det er den slags ROI, der gør den tekniske indsats det hele værd.

Login-muren: hvorfor din Amazon-anmeldelsesscraper stoppede med at virke

Den 14. november 2024 . Ændringen blev bekræftet i både og . Hvis du besøger /product-reviews/{ASIN}/ i et inkognitovindue, bliver du omdirigeret til en login-side i stedet for at få anmeldelsesdata.

Symptomerne er subtile: dit script får et 200 OK-svar, men HTML-bodyen indeholder en login-formular (name="email", id="ap_password") i stedet for anmeldelser. Ingen fejlkode. Ingen CAPTCHA. Bare ... ingenting, der er brugbart.

Amazon gjorde dette af hensyn til anti-bot og regional compliance. Håndhævelsen er ujævn — nogle gange indlæser et frisk browservindue et par anmeldelser, før muren slår til, især på første side — men for enhver scraper, der kører i skala, skal du regne med, at muren altid er aktiv.

Forskellige Amazon-domæner for lande (.de, .co.uk, .co.jp) håndhæver muren uafhængigt af hinanden. Som en bruger i et forum formulerede det: "der kræves et login for hvert land." Dine .com-cookies virker ikke på .co.uk.

Featured Reviews vs. fulde anmeldelser: hvad du stadig kan tilgå uden login

Amazons produktsider (/dp/{ASIN}/-URL'en) viser stadig cirka uden autentificering. De er udvalgt af Amazons algoritme og er nyttige til et hurtigt sentiment-tjek, men de kan ikke sorteres, filtreres eller pagineres.

De fulde anmeldelsessider (/product-reviews/{ASIN}/) — med sortering efter nyeste, filtrering på stjerner og pagination over hundredvis af anmeldelser — kræver login.

Hvis du kun har brug for et lille antal anmeldelser til et hurtigt overblik, så scrape produktsiden. Hvis du vil have hundredvis eller tusindvis, skal du håndtere autentificering.

Hvad du skal have på plads: Python-opsætning og biblioteker

Før vi skriver kode, er her opsætningen:

• Sværhedsgrad: Mellem (du er komfortabel med Python og har basal HTML-forståelse)
• Tidsforbrug: ~45 minutter for hele pipelinen; ~10 minutter for et simpelt scrape
• Det skal du bruge: Python 3.8+, Chrome-browser og en gyldig Amazon-konto

Installer de centrale biblioteker:

1pip install requests beautifulsoup4 lxml pandas textblob

Valgfrit (til avanceret sentimentanalyse):

1pip install transformers torch

Hvad er en ASIN? Det er Amazons 10-tegns produkt-id. Du finder den i enhver produkt-URL — for eksempel i amazon.com/dp/B0BCNKKZ91 er ASIN'en B0BCNKKZ91. Det er nøglen, du bruger i anmeldelses-URL'en.

Trin 1: Kom forbi login-muren med cookie-baseret autentificering

Den mest stabile løsning er at logge ind på Amazon i din browser, kopiere dine sessionscookies og injicere dem i din Python requests.Session(). Så undgår du de CAPTCHA'er og SMS-2FA-flow, som ofte spænder ben for login-automation med Selenium.

Du skal bruge disse syv cookies:

Sådan udtrækker du cookies fra Chrome DevTools

1. Log ind på amazon.com i Chrome
2. Åbn DevTools (F12 eller højreklik → Inspect)
3. Gå til Application → Storage → Cookies → https://www.amazon.com
4. Find hvert cookienavn i tabellen og kopiér værdien
5. Formatér dem som en streng adskilt af semikolon til Python

Sæt din session op sådan her:

1import requests
2session = requests.Session()
3# Indsæt dine cookie-værdier 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)

Vigtigt: Genbrug den samme session-instans på tværs af alle dine requests. Det holder cookies konsistente og efterligner en rigtig browser-session. Cookies holder typisk fra dage til uger under scraping-belastning, men hvis du begynder at blive sendt tilbage til login, skal du opdatere dem fra din browser.

For markeder uden for .com ændrer cookienavnene sig lidt — amazon.de bruger at-acbde i stedet for at-main, amazon.co.uk bruger at-acbuk, og så videre. Hvert marked kræver sin egen uafhængige session.

Trin 2: Byg requesten og parse anmeldelses-HTML med BeautifulSoup

Amazon-anmeldelses-URL'en følger dette mønster:

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

Kernefunktionen:

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    # Registrér login-mur
7    if "ap_email" in response.text or "Amazon Sign-In" in response.text:
8        raise Exception("Login-mur registreret — opdatér dine cookies")
9    if response.status_code != 200:
10        raise Exception(f"HTTP {response.status_code}")
11    return BeautifulSoup(response.text, "lxml")

Et lille trick, der hjælper: Før du rammer anmeldelsessiden, så besøg produktsiden først. Det skaber et mere naturligt browsermønster i din session.

1# Besøg produktsiden først (imiterer rigtig browsing)
2product_url = f"https://www.amazon.com/dp/{asin}"
3session.get(product_url, timeout=15)
4time.sleep(random.uniform(1, 3))
5# Gå derefter 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)

Trin 3: Brug stabile selektorer til at udtrække anmeldelsesdata (stop med at stole på CSS-klasser)

Her falder de fleste tutorials fra 2022–2023 fra hinanden. Amazon obfuskere CSS-klassenavne — de ændrer sig med jævne mellemrum, og som en frustreret udvikler skrev i en forumtråd: "ingen af dem havde bare én eneste fast struktur i navnene på span-taggenes klasser."

Løsningen: Amazon bruger data-hook-attributter på anmeldelseselementer, og de er bemærkelsesværdigt stabile. Det er semantiske identifikatorer, som Amazons egen frontend afhænger af, så de bliver ikke randomiseret.

Udtrækningskoden 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        # 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ø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        # Verificeret køb
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 kørt dette sæt selektorer mod flere ASINs i måneder nu, og data-hook-attributterne har ikke ændret sig én eneste gang. CSS-klasserne derimod har roteret mindst to gange i samme periode.

Trin 4: Håndter pagination og Amazons grænse på 10 sider

Amazon begrænser pageNumber-parameteren til 10 sider med 10 anmeldelser pr. side — et hårdt loft på cirka 100 anmeldelser pr. filterkombination. Knappen "Next page" forsvinder simpelthen efter side 10.

Grundlæggende pagination-loop:

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  # Der er ikke flere anmeldelser på siden
8    all_reviews.extend(page_reviews)
9    print(f"Side {page}: {len(page_reviews)} anmeldelser")

Sådan får du mere end 10 sider Amazon-anmeldelser

Workarounden er filter-bucketing. Hver kombination af filterByStar og sortBy får sit eget uafhængige 10-siders vindue.

Stjernefilter-værdier: one_star, two_star, three_star, four_star, five_star
Sorteringsværdier: recent, helpful (standard)

Ved at kombinere alle 5 stjernefiltre × 2 sorteringer kan du få adgang til op til 100 sider, altså 1.000 anmeldelser pr. produkt — og for produkter med ujævn stjernefordeling kommer du ofte meget tæt på hele anmeldelsessættet.

1star_filters = ["one_star", "two_star", "three_star", "four_star", "five_star"]
2sort_orders = ["recent", "helpful"]
3all_reviews = []
4seen_titles = set()  # Enkel deduplikering
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                # Dedupliker på kombinationen titel + forfatter
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"Samlet antal unikke anmeldelser: {len(all_reviews)}")

Der vil være overlap mellem buckets, så deduplikering er afgørende. Jeg bruger en kombination af anmeldelsestitel + forfatternavn som hurtig nøgle — ikke perfekt, men den fanger langt størstedelen af dubletterne.

Trin 5: Undgå anti-bot-forsvar (rotér, throttl, retry)

Amazon bruger AWS WAF Bot Control, og det er blevet markant mere aggressivt. Enkeltlag-forsvar (kun at rotere User-Agents, kun at tilføje forsinkelser) er ikke længere nok.

En retry-wrapper klar til 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            # Registrér blokeringer
16            if "validateCaptcha" in response.url or "Robot Check" in response.text:
17                wait = (2 ** attempt) * 5
18                print(f"CAPTCHA registreret. 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 limited ({response.status_code}). Venter {wait}s...")
24                time.sleep(wait)
25                continue
26            if "ap_email" in response.text:
27                raise Exception("Login-mur — cookies er udløbet")
28            return BeautifulSoup(response.text, "lxml")
29        except Exception as e:
30            if attempt == max_retries - 1:
31                raise
32            print(f"Forsøg {attempt + 1} fejlede: {e}")
33    return None

Et par ord om proxies: Amazon (AWS, GCP, Azure, DigitalOcean) på netværksniveau. Hvis du scraper mere end et par hundrede sider, er residential proxies i praksis nødvendige — regn med at bruge 50–200+ USD om måneden afhængigt af volumen. For mindre projekter (under 100 requests/dag) fungerer en forsigtig throttling fra din hjemm-IP ofte fint.

Amazon undersøger også TLS-fingerprints. Python's standard requests-bibliotek har en . Til scrapers i produktion bør du overveje curl_cffi, som imiterer rigtige browser-TLS-stakke. Til scraping i tutorial-skala (et par hundrede sider) klarer requests med gode headers som regel opgaven.

Trin 6: Eksportér dine scraped Amazon-anmeldelser til CSV eller Excel

Når du har samlet dine anmeldelser, er det ligetil at få dem over i et brugbart format med pandas:

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

Eksempel på output:

Til Excel-eksport: df.to_excel("amazon_reviews.xlsx", index=False) (kræver openpyxl).

Til Google Sheets fungerer gspread-biblioteket, men det kræver — oprette et projekt, aktivere to API'er, generere servicekonto-oplysninger, dele arket. Hvis det lyder som mere opsætning end selve scrapingen, tager du ikke fejl. (Det er netop et af de øjeblikke, hvor et værktøj som , der eksporterer til Google Sheets med ét klik, begynder at se meget fristende ud.)

Bonus: Tilføj sentimentanalyse til dine scraped anmeldelser med 5 linjer Python

De fleste scraping-guides stopper ved CSV-eksport. Men sentiment-score er det, der gør rå data til forretningsbeslutninger.

Den hurtigste baseline bruger TextBlob:

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

Det giver dig en polarity-score fra -1.0 (meget negativ) til +1.0 (meget positiv) for hver anmeldelse. Eksempel på output:

De interessante rækker er dem, der ikke passer sammen — en 3-stjernet anmeldelse med positiv tekst, eller en 5-stjernet anmeldelse med negativt sprog. De forskelle afslører ofte nuancerede kundeopfattelser, som stjerner alene ikke fanger.

For mere præcis modelkvalitet i produktion er anbefalingen Hugging Face Transformers. , og sammenlignet med leksikonbaserede værktøjer. Modellen nlptown/bert-base-multilingual-uncased-sentiment kan endda forudsige 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 top ved 5 stjerner, en mindre top ved 1 stjerne og en dal i midten. Det betyder, at gennemsnitlig rating ofte er en dårlig indikator for den reelle produktkvalitet. Segmentér 1-stjerne-klumpen og grav efter tilbagevendende temaer — det er ofte dér, en enkelt fejl, der kan løses, gemmer sig.

Den ærlige afvejning: DIY Python vs. betalte scraping-API'er vs. Thunderbit

Jeg har vedligeholdt Python-scrapere til Amazon, og jeg skal være ærlig: de går i stykker. Selektorer ændrer sig, cookies udløber, Amazon ruller en ny bot-detekteringslag ud, og pludselig går din lørdag formiddag med at debugge en scraper i stedet for at analysere data. Det samme frustrerer andre brugere i fora — DIY-scripts, der "virkede sidste måned", kræver nu konstant lapning.

Sådan sammenlignes de tre hovedtilgange:

Python giver dig fuld kontrol og er oprigtigt den bedste måde at forstå, hvordan web scraping fungerer under motorhjelmen. Betalte API'er (ScrapingBee, Oxylabs, Bright Data) giver mening til produktionspipelines, hvor oppetid er vigtigere end pris. Og for teams, der har brug for anmeldelsesdata uden udvikler-omkostninger — ecommerce operations, der følger konkurrenter ugentligt, marketingteams, der henter kundesprog til annoncecopy — er der en tredje vej.

Sådan scraper du Amazon-anmeldelser med Thunderbit (uden kode og uden vedligeholdelse)

Vi byggede til netop de scenarier, hvor det føles som overkill at vedligeholde en Python-scraper. Workflowet ser sådan ud:

1. Installer
2. Gå til Amazon-produktets anmeldelsesside i din browser (du er allerede logget ind, så login-muren er ikke et problem)
3. Klik på "AI Suggest Fields" — Thunderbit læser siden og foreslår kolonner som Author, Rating, Title, Review Text, Date og Verified Purchase
4. Klik på "Scrape" — data udtrækkes med det samme, inklusive indbygget pagination
5. Eksportér til Excel, Google Sheets, Airtable eller Notion

Den store fordel er, at Thunderbits AI læser sidens struktur forfra hver gang. Ingen CSS-selektorer at vedligeholde, ingen cookie-håndtering og ingen anti-bot-kode. Når Amazon ændrer deres HTML, tilpasser AI’en sig. For læsere, der vil have programmatisk adgang uden fuld DIY, tilbyder Thunderbit også en — struktureret dataudtræk via API med AI-baseret feltdetektion og uden selektorvedligeholdelse.

For mere dybdegående Amazon-data, se vores guides om og .

Tips til at scrape Amazon-anmeldelser i stor skala med Python

Hvis du scraper anmeldelser på tværs af mange ASINs, er der nogle vaner, der sparer dig for meget besvær:

• Batch dine ASINs med pauser mellem produkter, ikke kun mellem sider. Jeg bruger 10–15 sekunders pauser mellem ASINs.
• Dedupliker aggressivt. Når du kombinerer flere stjernefiltre og sorteringskombinationer, får du overlap i anmeldelserne. Brug et sæt af (title, author, date)-tupler som deduplikeringsnøgle.
• Log fejl. Track hvilke ASIN + side + filter-kombinationer der fejlede, så du kan køre dem igen uden at scrape alt på ny.
• Gem i en database til større projekter. En simpel SQLite-database skalerer langt bedre end CSV-filer, der bare vokser:

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

• Planlæg gentagne scrapes. Til løbende overvågning kan du sætte et cron-job op eller bruge Thunderbits Scheduled Scraper-funktion — beskriv URL'en og tidsplanen, så klarer den resten uden en server.

For flere metoder dækker vores indlæg om og også andre muligheder.

Et kort ord om jura og etik

Amazons forbyder eksplicit "the use of any robot, spider, scraper, or other automated means to access Amazon Services." Når det er sagt, har nyere amerikansk retspraksis været mere gunstig over for scraping af offentlige data. I slog en føderal domstol fast, at scraping af offentligt tilgængelige data ikke overtræder servicevilkår, når scraperen ikke er en indlogget "user."

Nuancen er, at scraping bag et login (som denne guide handler om) bringer dig ind i kontraktretligt territorium, fordi du accepterede Amazons ToS, da du oprettede din konto. Scraping af offentligt synlige featured reviews indebærer mindre juridisk risiko end scraping bag login-muren.

Praktiske retningslinjer: videredistribuér ikke scraped data kommercielt, scrape ikke personlige brugerdata ud over det, der er offentligt vist, respekter robots.txt, og rådfør dig med en jurist ved store eller kommercielle projekter. Det her er ikke juridisk rådgivning. For mere om det juridiske landskab, se vores overblik over .

Konklusion: scrape Amazon-anmeldelser med Python — eller spring koden helt over

Hurtig opsummering af det, guiden har været igennem:

• Login-muren er reel, men kan løses med cookie-baseret autentificering — kopiér 7 cookies fra din browser og injicér dem i en requests.Session()
• Brug data-hook-selektorer, ikke CSS-klasser, for udtræk, der ikke går i stykker hver anden uge
• Kombinér stjernefiltre og sorteringsordrer for at komme forbi grænsen på 10 sider og få adgang til 500+ anmeldelser pr. produkt
• Tilføj sentimentanalyse med TextBlob for en hurtig baseline eller Hugging Face Transformers for højere præcision i produktion
• Vedligehold anti-bot-forsvar: throttling, rotation af User-Agent, eksponentiel backoff og residential proxies i stor skala

Python giver dig fuld kontrol og er den bedste måde at forstå, hvad der sker under motorhjelmen. Men hvis dit behov er "jeg skal have konkurrenters anmeldelser i et regneark inden fredag" snarere end "jeg vil bygge en produktionsklar datapipeline," er den løbende vedligeholdelse af en custom scraper måske ikke umagen værd.

håndterer autentificering, selektorer, pagination og eksport med klik — prøv og se, om den passer til din arbejdsgang. I takt med at Amazon strammer anti-bot-foranstaltningerne, bliver AI-drevne værktøjer, der tilpasser sig i realtid, mindre en rar ekstra feature og mere en nødvendighed.

Du kan også udforske vores for videoguider til scraping-workflows.

FAQs

1. Kan man scrape Amazon-anmeldelser uden at logge ind?

Ja, men kun de cirka 8 "featured reviews", der vises på produktsiden (/dp/{ASIN}/). De fulde anmeldelsessider med sortering, filtrering og pagination kræver autentificering fra slutningen af 2024. Til de fleste forretningscases skal du håndtere login-muren.

2. Er det lovligt at scrape Amazon-anmeldelser?

Amazons Terms of Service forbyder automatiseret scraping. Men nyere amerikansk retspraksis (Meta v. Bright Data, 2024; hiQ v. LinkedIn) understøtter scraping af offentligt tilgængelige data. Scraping bag et login indebærer større juridisk risiko, fordi du har accepteret Amazons ToS. Kontakt en jurist ved kommerciel brug.

3. Hvor mange Amazon-anmeldelser kan jeg scrape pr. produkt?

Amazon begrænser anmeldelsessider til 10 pr. sorterings- og stjernefilterkombination. Ved at bruge alle 5 stjernefiltre × 2 sorteringsordrer kan du få adgang til op til 100 sider (cirka 1.000 anmeldelser) pr. produkt. Med nøgleordsfiltre er det teoretiske loft højere, men med betydelig dublering.

4. Hvilket Python-bibliotek er bedst til at scrape Amazon-anmeldelser?

requests + BeautifulSoup til statisk HTML-parsing er den mest almindelige og pålidelige kombination. Selenium er nyttigt, når JavaScript-rendering er påkrævet. Hvis du vil have et no-code-alternativ, der håndterer login-mure og pagination automatisk, så prøv .

5. Hvordan undgår jeg at blive blokeret, når jeg scraper Amazon?

Roter User-Agent-strenge fra en pulje på 10+ rigtige browser-strenge, tilføj tilfældige pauser på 2–5 sekunder mellem requests, implementér eksponentiel backoff på 503/429-fejl, brug residential proxies i stor skala (datacenter-IP'er bliver ofte blokeret på forhånd), og hold sessioncookies konsistente på tværs af requests. Hvis du vil have en løsning uden vedligeholdelse, håndterer Thunderbit anti-bot-forsvar automatisk via din browser-session.

Læs mere