Jeg testet 4 måter å hente Amazon Best Sellers med Python på – og ...

I forrige helg drakk jeg meg gjennom en hel kanne kaffe mens jeg prøvde fire ulike måter å hente data fra Amazons Best Sellers-side på. To fungerte skikkelig bra, én holdt på å få IP-en min blokkert, og én tok bokstavelig talt to klikk. Her er alt jeg lærte.

Amazon er et monster av en markedsplass — , , og et Best Sellers Rank (BSR)-system som oppdateres hver time. Driver du med produktresearch for FBA, prisanalyse mot konkurrenter, eller bare vil oppdage trender før konkurrentene dine gjør det, er data fra Best Sellers gull verdt.

Men å få disse dataene ut av Amazon og inn i et regneark? Der blir det interessant. Jeg testet requests + BeautifulSoup, Selenium, en scraping-API og (vår egen kodefrie AI-nettskraper) for å se hvilken metode som faktisk leverer — og hvilke som bare gir deg en CAPTCHA-side å stirre på.

Hva er Amazon Best Sellers, og hvorfor bør du bry deg?

Amazon Best Sellers Rank (BSR) er Amazons sanntidstabell over produkter, rangert etter salgsvolum innen hver kategori. Tenk på det som en popularitetskonkurranse, oppdatert hver time, basert på både nylige og historiske salgsdata. Amazon beskriver det slik:

"Amazon Best Sellers-beregningen er basert på Amazon-salg og oppdateres hver time for å gjenspeile nylige og historiske salg av hver vare som selges på Amazon." —

Best Sellers-siden viser de 100 mest solgte produktene i hver kategori, fordelt på to sider med 50 produkter per side. Side 1 dekker rang #1–50, side 2 dekker #51–100. Amazon har bekreftet at sidevisninger og kundevurderinger IKKE påvirker BSR — det er kun salg som teller.

Hvem trenger egentlig disse dataene? E-handelsaktører som leter etter produkter til FBA, salgsavdelinger som bygger konkurranseinnsikt, driftsteam som følger prisutvikling, og markedsanalytikere som kartlegger vekst i kategorier. Etter min erfaring ender alle som selger på eller konkurrerer med Amazon opp med å trenge disse dataene i et regneark.

Hvorfor hente Amazon Best Sellers med Python?

Manuell produktresearch sluker tid. En fant at ansatte bruker 9,3 timer i uken bare på å søke etter og samle inn informasjon. For e-handelsteam betyr det timer brukt på å klikke gjennom Amazon-sider, kopiere produktnavn og priser, og lime alt inn i regneark — bare for å gjøre det samme igjen neste uke.

Her er en rask oversikt over brukstilfellene som gjør det verdt å hente Best Sellers-data:

Avkastningen er reell: En blant 2 700 handelsprofesjonelle fant at AI-verktøy sparer e-handelsfolk i snitt . Og selgere som bruker automatisert prisovervåking holder Buy Box , mot 42 % for manuelle løsninger — en salgsøkning på 37 % drevet av raskere reaksjoner på prisendringer.

4 måter å hente Amazon Best Sellers med Python: en rask sammenligning

Før vi går inn i steg-for-steg-veiledningene, her er sammenligningen jeg skulle ønske jeg hadde før jeg begynte å teste. Tabellen bør hjelpe deg å velge riktig metode for situasjonen din:

Hvis du vil lære grunnleggende Python-scraping, start med metode 1 eller 2. Hvis du trenger pålitelighet i produksjonsskala, velg metode 3. Hvis du vil ha resultater på to klikk uten å skrive kode, gå rett til metode 4.

Før du begynner

• Vanskelighetsgrad: Nybegynner til middels (avhengig av metode)
• Tidsbruk: ca. 15 minutter for Thunderbit, ca. 45 minutter for Python-metodene
• Du trenger: Python 3.8+ (for metode 1–3), Chrome-nettleser, (for metode 4), og en Amazon Best Sellers-kategori-URL

Metode 1: Hent Amazon Best Sellers med requests + BeautifulSoup

Dette er den lette og nybegynnervennlige metoden — ingen nettleserautomatisering, bare HTTP-forespørsler og HTML-parsing. Den lærte meg også mest om Amazons anti-scraping-forsvar.

Steg 1: Sett opp miljøet ditt

Installer pakkene du trenger:

1pip install requests beautifulsoup4 pandas

Sett deretter opp importene:

1import requests
2from bs4 import BeautifulSoup
3import pandas as pd
4import random
5import time

Steg 2: Send en forespørsel med realistiske headere

Amazon blokkerer forespørsler som ser ut som roboter. Det mest grunnleggende forsvaret er en User-Agent-header som etterligner en ekte nettleser. Her er et eksempel med en samling av aktuelle, realistiske User-Agent-strenger (hentet fra , mars 2026):

1USER_AGENTS = [
2    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
3    "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",
4    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0",
5    "Mozilla/5.0 (Macintosh; Intel Mac OS X 15.7; 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]
8headers = {"User-Agent": random.choice(USER_AGENTS)}
9url = "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/"
10response = requests.get(url, headers=headers)
11print(response.status_code)  # Skal være 200

Hvis du ser statuskode 200, er du inne. Hvis du ser 503 eller blir sendt videre til en CAPTCHA-side, har Amazon flagget forespørselen din.

Steg 3: Parse produktdata med BeautifulSoup

Sjekk HTML-koden på Amazon-siden ved hjelp av nettleserens DevTools (høyreklikk → Inspiser). Produktcontainerne bruker ID-en gridItemRoot. Inne i hver container finner du produktnavn, pris, vurdering og URL.

1soup = BeautifulSoup(response.text, "html.parser")
2products = []
3for item in soup.find_all("div", id="gridItemRoot"):
4    title_tag = item.find("div", class_="_cDEzb_p13n-sc-css-line-clamp-3_g3dy1")
5    price_tag = item.find("span", class_="_cDEzb_p13n-sc-price_3mJ9Z")
6    link_tag = item.find("a", class_="a-link-normal")
7    title = title_tag.get_text(strip=True) if title_tag else "N/A"
8    price = price_tag.get_text(strip=True) if price_tag else "N/A"
9    url = "https://www.amazon.com" + link_tag["href"] if link_tag else "N/A"
10    products.append({"Title": title, "Price": price, "URL": url})

Advarsel: Klassenavnene med prefikset _cDEzb_ er CSS-modul-hasher som Amazon genererer på nytt med jevne mellomrom. ID-en gridItemRoot og klassen a-link-normal er mer stabile, men verifiser alltid selektorene i DevTools før du kjører scraperen.

Steg 4: Eksporter til CSV

1df = pd.DataFrame(products)
2df.to_csv("amazon_best_sellers.csv", index=False)
3print(f"Hentet {len(products)} produkter")

Hva du kan forvente — og hva som går galt

I testen min returnerte denne metoden rundt 30 produkter i stedet for 50. Det er ikke en feil i koden — det er Amazons lazy loading. Bare rundt 30 produkter lastes inn ved første sidevisning; resten kommer etter scrolling, som krever JavaScript-kjøring som requests ikke håndterer.

Andre begrensninger:

• IP-blokkering skjer raskt uten proxy-rotasjon (jeg ble blokkert etter omtrent 15 forespørsler i rask rekkefølge)
• CSS-selektorer bryter når Amazon oppdaterer sidelayouten — og det gjør de jevnlig
• Ingen støtte for paginering rett ut av boksen

Til å lære Python-scraping er dette en fin metode. Til produksjon er den skjør.

Metode 2: Hent Amazon Best Sellers med Selenium

Selenium løser lazy-loading-problemet ved å kjøre en ekte nettleser — tyngre å sette opp, men den fanger alle 50 produktene per side.

Steg 1: Installer Selenium

1pip install selenium pandas

Gode nyheter: Fra Selenium 4.6+ trenger du ikke lenger webdriver-manager. Selenium Manager håndterer nedlasting av drivere automatisk.

1from selenium import webdriver
2from selenium.webdriver.chrome.options import Options
3from selenium.webdriver.common.by import By
4from selenium.webdriver.common.keys import Keys
5import time
6import pandas as pd
7options = Options()
8options.add_argument("--headless=new")
9options.add_argument("--window-size=1920,1080")
10options.add_argument("--disable-blink-features=AutomationControlled")
11driver = webdriver.Chrome(options=options)

Flagget --headless=new (introdusert i Chrome 109+) bruker samme rendering-pipeline som vanlig Chrome, noe som gjør det vanskeligere for Amazon å oppdage deg.

Steg 2: Scroll forbi lazy loading

Dette er steget som gjør Selenium verdt oppsettet. Amazon Best Sellers laster bare inn rundt 30 produkter i starten — resten dukker opp etter scrolling.

1def scroll_page(driver, scrolls=5, delay=2):
2    for _ in range(scrolls):
3        driver.find_element(By.TAG_NAME, "body").send_keys(Keys.PAGE_DOWN)
4        time.sleep(delay)
5driver.get("https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/")
6time.sleep(3)
7scroll_page(driver)

Etter scrolling bør alle 50 produktene være rendret i DOM-en. Jeg fant ut at 5 side-ned-scroll med 2 sekunders forsinkelse var nok, men du må kanskje justere dette avhengig av linjehastigheten din.

Steg 3: Hent ut produktdata

1items = driver.find_elements(By.ID, "gridItemRoot")
2products = []
3for item in items:
4    try:
5        title = item.find_element(By.CSS_SELECTOR, "div._cDEzb_p13n-sc-css-line-clamp-3_g3dy1").text
6    except:
7        title = "N/A"
8    try:
9        price = item.find_element(By.CSS_SELECTOR, "span._cDEzb_p13n-sc-price_3mJ9Z").text
10    except:
11        price = "N/A"
12    try:
13        url = item.find_element(By.CSS_SELECTOR, "a.a-link-normal").get_attribute("href")
14    except:
15        url = "N/A"
16    products.append({"Title": title, "Price": price, "URL": url})

Det er viktig å pakke inn hver uthenting i try/except — noen produkter kan være utsolgt eller mangle felt, og du vil ikke at ett dårlig element skal krasje hele prosessen.

Steg 4: Håndter paginering

Amazon deler 100 Best Sellers over to sider med ulike URL-strukturer:

1urls = [
2    "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/",
3    "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/ref=zg_bs_pg_2_electronics?_encoding=UTF8&pg=2"
4]
5all_products = []
6for url in urls:
7    driver.get(url)
8    time.sleep(3)
9    scroll_page(driver)
10    # ... hent produkter som over ...
11    all_products.extend(products)
12driver.quit()

Hva du kan forvente

I testen min fanget Selenium alle 50 produktene per side — en klar seier over requests + BS4. Ulempen: Det tok rundt 45 sekunder per side (inkludert scroll-forsinkelser), og jeg ble fortsatt flagget etter å ha kjørt det for mange ganger uten proxy-rotasjon. Selenium er også mulig å oppdage for Amazons bot-forsvar selv med anti-detection-flaggene — ved seriøs skala trenger du ekstra tiltak (se anti-ban-oppskriften nedenfor).

Andre utfordringer:

• Versjonsmismatch mellom WebDriver og nettleser skjer fortsatt av og til, selv om Selenium Manager har gjort dette mye sjeldnere
• CSS-selektorer må oppdateres hver gang Amazon endrer DOM-en sin
• Minnebruken er høy — hver nettleserinstans sluker 200–400 MB RAM

Metode 3: Hent Amazon Best Sellers med en scraping-API

Scraping-API-er er «la noen andre ta seg av de vanskelige delene»-metoden. Tjenester som Scrape.do, Oxylabs og ScrapingBee håndterer proxy-rotasjon, JavaScript-rendering og anti-bot-forsvar — du sender bare en URL og får tilbake HTML eller JSON.

Slik fungerer det

Du sender mål-URL-en din til API-endepunktet. API-et renderer siden ved hjelp av en ekte nettleser på deres infrastruktur, roterer proxyer, håndterer CAPTCHA-er og returnerer ren HTML. Deretter parser du den mottatte HTML-en med BeautifulSoup som vanlig.

Steg 1: Send en forespørsel gjennom API-et

Her er et eksempel med Scrape.do (prisene starter på $29/måned for 150 000 credits, 1 credit = 1 forespørsel uansett rendering):

1import requests
2from bs4 import BeautifulSoup
3api_token = "YOUR_API_TOKEN"
4target_url = "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/"
5api_url = f"https://api.scrape.do?token={api_token}&url={target_url}&render=true&geoCode=us"
6response = requests.get(api_url)
7soup = BeautifulSoup(response.text, "html.parser")

Derfra er parsingen identisk med metode 1 — samme selektorer, samme uthentingslogikk.

Prisrealitet

Her er hva de store API-ene tar per 1 000 Amazon-forespørsler på beste tilgjengelige nivå:

Fordeler og ulemper

Fordeler: Høy pålitelighet ( på Amazon for de beste leverandørene), ingen driver-vedlikehold, håndterer anti-bot automatisk, skalerer godt.

Ulemper: Betaling per forespørsel (kostnadene vokser med volum), du må fortsatt skrive parseringskode, og du er fortsatt sårbar for endringer i CSS-selektorer. For 100 000 sider i måneden blir totalregnestykket dramatisk: Å bygge selv koster omtrent — en besparelse på 71 %.

Break-even-punktet ligger vanligvis rundt 500 000–1 million forespørsler per måned. Under det veier tidsbesparelsen ved API-er som regel tyngre enn kostnaden.

Metode 4: Hent Amazon Best Sellers med Thunderbit (uten Python)

Full åpenhet: Jeg jobber i Thunderbit, så ta denne delen med det i bakhodet. Når det er sagt, testet jeg faktisk alle fire metodene rygg mot rygg, og forskjellen i tid til data var slående.

er en AI-nettskraper som kjører som en Chrome-utvidelse. Hovedideen: I stedet for å skrive CSS-selektorer eller Python-kode, leser AI-en siden og finner ut hva som skal hentes ut. For Amazon Best Sellers finnes det dessuten ferdige maler som fungerer med ett klikk.

Steg 1: Installer Thunderbit Chrome-utvidelsen

Gå til og klikk "Legg til i Chrome." Registrer en gratis konto — gratisnivået gir deg nok credits til å teste dette.

Steg 2: Åpne Amazon Best Sellers-siden

Åpne en hvilken som helst kategori-side for Amazon Best Sellers i Chrome. For eksempel: https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/

Steg 3: Klikk "AI Suggest Fields"

Åpne Thunderbit-sidepanelet og klikk "AI Suggest Fields." AI-en analyserer sideoppsettet og foreslår kolonner: produktnavn, pris, vurdering, bilde-URL, leverandør, produkt-URL og rangering. I testen min identifiserte den alle relevante feltene på omtrent 3 sekunder.

Du kan gi nytt navn til kolonner, fjerne dem eller legge til nye. Du kan til og med legge inn egne AI-prompter per felt — for eksempel "klassifiser som Elektronikk/Klær/Hjem" for å legge til en kategoritagg på hvert produkt.

Steg 4: Klikk "Scrape"

Trykk på "Scrape"-knappen. Thunderbit fyller en strukturert tabell med alle produktdataene fra siden. I cloud-modus kan den behandle opptil 50 sider samtidig i parallell, og håndterer lazy loading og paginering automatisk.

Steg 5: Eksporter gratis

Klikk "Export" og velg hvor du vil sende dataene: Excel, Google Sheets, Airtable eller Notion. Alle eksportfunksjoner er gratis på alle planer — ingen skjulte kostnader.

Hele prosessen tok meg omtrent 90 sekunder fra jeg åpnet siden til jeg hadde et komplett regneark. Til sammenligning tok metode 1 omtrent 20 minutter (inkludert feilsøking av lazy loading-problemet), metode 2 tok omtrent 35 minutter (inkludert Selenium-oppsett), og metode 3 tok omtrent 15 minutter (inkludert oppsett av API-konto).

Hvorfor Thunderbit håndterer Amazon godt

Fordi AI-en leser siden på nytt hver gang, tilpasser den seg layoutendringer automatisk — ingen CSS-selektorer å vedlikeholde. Dette treffer direkte den vanligste klagen i scraping-forum: "En enkel webscraper holder ikke, du må legge inn så mange 'feller' for elementendringer." Når Amazon endrer DOM-en sin (noe som skjer ofte), trenger du ikke å oppdatere noe.

Cloud scraping-modus håndterer proxy-rotasjon, rendering og anti-bot-tiltak uten at du ser det. For brukere som vil ha en løsning som bare fungerer, fjerner dette hele anti-ban-stresset.

Anti-ban-håndboken: Slik unngår du å bli blokkert av Amazon

Amazons bot-forsvar er aggressivt. Jeg fikk IP-en min midlertidig blokkert under testing, og forumbrukere rapporterer det samme: "feil overalt, Amazon begynte til og med å sende meg videre til startsiden." Hvis du går Python-ruten (metode 1–3), er denne delen avgjørende.

Her er en lagdelt strategi, rangert fra grunnleggende til avansert:

1. Roter User-Agent-strenger

Å sende samme User-Agent om og om igjen er et rødt flagg. Bruk puljen med 5+ strenger fra kodeeksempelet i metode 1, og velg tilfeldig én per forespørsel:

1headers = {"User-Agent": random.choice(USER_AGENTS)}

2. Legg inn tilfeldige pauser mellom forespørsler

Faste pauser er lette å oppdage (mønstre). Tilfeldige er tryggere:

1time.sleep(random.uniform(2, 5))

Jeg fant ut at 2–5 sekunder mellom forespørsler holdt meg under radaren for små batcher (under 50 forespørsler). For større kjøringer bør du øke til 3–7 sekunder.

3. Bruk proxy-rotasjon

Dette er den store. viser at residential proxies i snitt har rundt 94 % suksess på Amazon, mot rundt 59 % for datacenter-proxyer — et gap på 35 prosentpoeng. Amazons deteksjonsstakk inkluderer TLS-fingeravtrykk, atferdsanalyse og rate-limiting per IP, så vanlige datacenter-IP-er blir flagget i løpet av sekunder.

Residential-proxyer er dyrere ($2–$12 per GB avhengig av leverandør), men mye mer pålitelige. Eksempel:

1proxies = {
2    "http": "http://user:pass@residential-proxy.example.com:8080",
3    "https": "http://user:pass@residential-proxy.example.com:8080"
4}
5response = requests.get(url, headers=headers, proxies=proxies)

4. Styrk nettleserfingeravtrykket ditt (Selenium)

1options.add_argument('--disable-blink-features=AutomationControlled')
2options.add_experimental_option("excludeSwitches", ["enable-automation"])
3options.add_experimental_option('useAutomationExtension', False)
4# Etter driver-init, fjern navigator.webdriver-flagget
5driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
6    'source': "Object.defineProperty(navigator, 'webdriver', {get: () => undefined})"
7})

5. Håndter sesjoner og cookies

Å beholde cookies mellom forespørsler gjør at scraperen din ser mer ut som en ekte brukersesjon:

1session = requests.Session()
2# Besøk først startsiden for å få realistiske cookies
3session.get("https://www.amazon.com", headers=headers)
4time.sleep(2)
5# Hent deretter målsiden
6response = session.get(target_url, headers=headers)

6. Når du bør slippe hele hodepinen

For brukere som ikke vil håndtere noe av dette selv, tar Thunderbits cloud scraping seg av proxy-rotasjon, rendering og anti-bot-tiltak automatisk. Scraping-API-er håndterer også det meste av dette rett ut av boksen. Etter min erfaring overstiger tiden du bruker på å feilsøke anti-ban-problemer ofte tiden du bruker på å skrive selve scraping-koden — så en løsning som bare fungerer har faktisk avkastning.

Berikelse på undersider: Hent produktsider for rikere data

Best Sellers-listen viser bare grunnleggende informasjon — tittel, pris, vurdering, rang. Men den virkelige verdien for FBA-research ligger på de enkelte produktsidene. Her er hva du går glipp av hvis du bare henter listen:

Feltet "Dato først tilgjengelig" er spesielt verdifullt — det forteller hvor lenge et produkt har vært på markedet, som er et nøkkelsignal i konkurranseanalyse. Og antall selgere og Buy Box-eier hjelper deg å vurdere om en produktnisje er verdt å gå inn i (hvis Amazon selv har over 30 % Buy Box-andel, er konkurransen ekstremt tøff).

Python-tilnærming: Løp gjennom produkt-URL-er

Etter at du har samlet produkt-URL-ene fra listesiden, går du gjennom hver av dem med en pause:

1for product in products:
2    time.sleep(random.uniform(3, 6))
3    detail_response = session.get(product["URL"], headers={"User-Agent": random.choice(USER_AGENTS)})
4    detail_soup = BeautifulSoup(detail_response.text, "html.parser")
5    # Hent merke
6    brand_tag = detail_soup.find("a", id="bylineInfo")
7    product["Brand"] = brand_tag.get_text(strip=True) if brand_tag else "N/A"
8    # Hent ASIN fra sidekoden eller URL-en
9    # Hent Dato først tilgjengelig fra produktdetaljtabellen
10    # ... flere felt ...

Vær obs: Å treffe 100 individuelle produktsider øker blokkering-risikoen betydelig. Sett av budsjett til proxy-rotasjon og lengre pauser.

Thunderbit-tilnærming: Berikelse av undersider med ett klikk

Etter at du har hentet listesiden inn i en tabell, klikker du "Scrape Subpages" i Thunderbit. AI-en besøker hver produkt-URL og beriker tabellen med flere kolonner — merke, ASIN, spesifikasjoner, egenskaper — automatisk. Ingen ekstra kode, selektorer eller oppsett. Dette er spesielt nyttig for e-handelsteam som trenger hele bildet for innkjøpsbeslutninger, men som ikke vil skrive og vedlikeholde en parser for produktsider.

Automatiser gjentatte scraping-oppgaver: Overvåk Best Sellers over tid

En engangshenting er nyttig, men løpende overvåking er der den virkelige konkurransefordelen ligger. Å følge med på hvilke produkter som stiger og faller, oppdage trender tidlig og overvåke prisendringer over uker eller måneder — det er dette som skiller tilfeldig research fra datadrevne beslutninger.

Python-tilnærming: Planlegging med cron

På Linux/Mac kan du planlegge Python-skriptet ditt med cron. Her er crontab-oppføringen for en daglig henting kl. 08:00:

10 8 * * * /usr/bin/python3 /home/user/amazon_scraper.py >> /home/user/logs/scrape.log 2>&1

For en ukentlig henting på mandag kl. 09:00:

10 9 * * 1 /usr/bin/python3 /home/user/amazon_scraper.py >> /home/user/logs/scrape.log 2>&1

På Windows bruker du Task Scheduler for å gjøre det samme. For alltid-på-planlegging uten å måtte la laptopen stå på, kan du deploye til en VPS eller AWS Lambda — men det øker kompleksiteten i infrastrukturen.

Legg til logging og feilmeldinger for å fange opp mislykkede kjøringer. Det er ingenting verre enn å oppdage at scraperen din gikk i stykker for to uker siden uten at du visste det.

Thunderbit-tilnærming: Scheduled Scraper i vanlig språk

Thunderbits Scheduled Scraper lar deg beskrive intervallet med naturlig språk — skriv "hver mandag kl. 09" eller "hver dag kl. 08", og AI-en tolker planen. Hentinger kjøres på Thunderbits skyløsning (ingen nettleser eller datamaskin trenger å være på), og data eksporteres automatisk til Google Sheets eller Airtable. Dette gir et levende overvåkingsdashboard uten serveradministrasjon — ideelt for driftsteam som vil ha kontinuerlig oversikt uten DevOps-arbeidet.

Juridiske og etiske hensyn når du henter data fra Amazon

Jeg er ikke jurist, og dette er ikke juridisk rådgivning. Men å ignorere det juridiske landskapet i en scraping-veiledning ville vært uansvarlig — forumbrukere tar opp ToS-bekymringer eksplisitt, og med god grunn.

Amazons robots.txt: Per 2026 inneholder Amazons robots.txt over 80 spesifikke Disallow-stier, men /gp/bestsellers/ er IKKE eksplisitt blokkert for vanlige user agents. Derimot får 35+ AI-spesifikke user agents (ClaudeBot, GPTBot, Scrapy osv.) et generelt Disallow: /. At noe ikke er eksplisitt blokkert betyr ikke at Amazon godkjenner scraping.

Amazons bruksvilkår: Amazons (oppdatert mai 2025) forbyr uttrykkelig "å bruke noen automatisert prosess eller teknologi for å få tilgang til, skaffe, kopiere eller overvåke noen del av Amazon-nettstedet" uten skriftlig tillatelse. Dette er ikke teoretisk — Amazon i november 2025 for uautorisert automatisert tilgang og fikk medhold i et midlertidig forbud.

Prejudikatet hiQ v. LinkedIn: I (Ninth Circuit, 2022) slo retten fast at scraping av offentlig tilgjengelige data sannsynligvis ikke bryter Computer Fraud and Abuse Act. Men hiQ inngikk til slutt forlik og gikk med på å slutte å scrape — å vinne på CFAA beskytter deg ikke mot kontraktsbruddskrav.

Praktiske retningslinjer:

• Hent bare offentlig tilgjengelige data (priser, BSR, produkttitler — ikke personopplysninger)
• Respekter rate limits og ikke overbelast serverne
• Bruk data til legitim konkurranseinnsikt
• Snakk med egen juridisk rådgiver før du scraper i stor skala
• Vær klar over at nå har omfattende personvernlovgivning

Thunderbits cloud scraping bruker vanlige nettleserlignende forespørselsmønstre, men du bør alltid få dette vurdert av egen juridisk rådgiver.

Hvilken metode bør du bruke? En rask beslutningsguide

Kortversjonen:

• "Jeg lærer Python og vil ha et helgeprosjekt." → Metode 1 (requests + BeautifulSoup). Du lærer masse om HTTP-forespørsler, HTML-parsing og Amazons bot-forsvar.
• "Jeg må hente sider med mye JavaScript eller innloggede sesjoner." → Metode 2 (Selenium). Den er tyngre, men håndterer dynamisk innhold.
• "Jeg kjører scraping i produksjon og i stor skala." → Metode 3 (Scraping-API). La noen andre håndtere proxyer og rendering. favoriserer API-er under 500 000 forespørsler per måned.
• "Jeg er ikke utvikler og vil ha data på 2 minutter." → Metode 4 (). Ingen kode, ingen selektorer, intet vedlikehold.
• "Jeg trenger løpende overvåking uten serveradministrasjon." → Thunderbit Scheduled Scraper. Sett det opp og glem det.

Konklusjon og viktigste lærdommer

Etter en helg med testing var dette det som faktisk satt igjen:

requests + BeautifulSoup er bra for læring, men begrensningen med lazy loading (bare rundt 30 av 50 produkter) og skjøre CSS-selektorer gjør det lite praktisk i produksjon.

Selenium løser lazy-loading-problemet og fanger alle 50 produktene per side, men det er tregt, minnekrevende og fortsatt mulig for Amazon å oppdage.

Scraping-API-er gir best pålitelighet for scraping i produksjonsskala — på Amazon — men kostnadene vokser, og du må fortsatt skrive parseringskode.

Thunderbit ga klart raskest vei fra side til data. AI-en håndterer layoutendringer, lazy loading, paginering og anti-bot-tiltak uten oppsett. For ikke-tekniske brukere eller team som trenger gjentatte data uten DevOps-overhead, er det det mest praktiske valget.

Den største lærdommen? Amazons bot-forsvar og hyppige layoutendringer gjør at løsninger uten vedlikehold sparer mest tid over tid. Hver time du bruker på å feilsøke ødelagte selektorer og rotere proxyer, er en time du ikke bruker på faktisk analyse.

Vil du prøve den kodefrie tilnærmingen? gir deg nok credits til å hente noen få Best Sellers-kategorier og se resultatene selv. Foretrekker du Python-ruten? Kodeeksemplene over bør få deg i gang. Uansett ender du opp med Amazon Best Seller-data i et regneark i stedet for å stirre på en nettleserfane.

For mer om webscraping-metoder, se guidene våre om , , og . Du kan også se steg-for-steg-gjennomganger på .

Les mer