Jag testade 4 sätt att skrapa Amazon Best Sellers med Python och ...

Förra helgen brände jag igenom en hel kaffekanna medan jag testade att skrapa Amazons Best Sellers-sida på fyra olika sätt. Två fungerade riktigt bra, ett var nära att få min IP bannad, och ett tog bokstavligen två klick. Här är allt jag lärde mig.

Amazon är en enorm marknadsplats — , och ett Best Sellers Rank-system (BSR) som uppdateras varje timme. Om du gör produktresearch för FBA, analyserar konkurrenspriser eller bara försöker upptäcka trender innan konkurrenterna gör det, är data från Best Sellers rena guldet.

Men att få ut den datan från Amazon och in i ett kalkylblad? Det är där det blir intressant. Jag testade requests + BeautifulSoup, Selenium, en scraping-API-lösning och (vår egen kodfria AI-webbskrapare) för att se vilken metod som faktiskt levererar — och vilka som lämnar dig stirrande på en CAPTCHA-sida.

Vad är Amazon Best Sellers egentligen, och varför ska du bry dig?

Amazon Best Sellers Rank (BSR) är Amazons realtidslista som rangordnar produkter efter försäljningsvolym inom varje kategori. Tänk på det som en popularitetstävling som uppdateras varje timme, baserad på både senaste och historiska försäljningsdata. Amazon beskriver det så här:

"The Amazon Best Sellers calculation is based on Amazon sales and is updated hourly to reflect recent and historical sales of every item sold on Amazon." —

Best Sellers-sidan visar de 100 mest sålda produkterna per kategori, uppdelade på två sidor med 50 produkter vardera. Sida 1 täcker plats #1–50, sida 2 täcker #51–100. Amazon har bekräftat att sidvisningar och kundrecensioner INTE påverkar BSR — det handlar enbart om försäljning.

Vem har nytta av den här datan? E-handlare som letar produkter för FBA, säljteam som bygger konkurrensinsikter, operationsteam som följer prisutveckling och marknadsanalytiker som bevakar kategoritillväxt. Enligt min erfarenhet behöver alla som säljer på, eller konkurrerar med, Amazon förr eller senare den här datan i ett kalkylblad.

Varför skrapa Amazon Best Sellers med Python?

Manuell produktresearch slukar tid. En visade att anställda lägger 9,3 timmar i veckan bara på att söka efter och samla information. För e-handelsteam betyder det timmar av klickande i Amazon, kopierande av produktnamn och priser, och klistrande in i kalkylblad — bara för att göra om allt nästa vecka.

Här är en snabb överblick över användningsområdena som gör det värt att skrapa Best Sellers:

Avkastningen är verklig: en bland 2 700 commerce-proffs visade att AI-verktyg sparar e-handelsarbetare i snitt . Och säljare som använder automatiserad prisbevakning vinner Buy Box jämfört med 42 % för manuella bevakare — en ökning av försäljningen med 37 % tack vare snabbare reaktioner på prisändringar.

4 sätt att skrapa Amazon Best Sellers med Python: en snabb jämförelse

Innan vi går in i steg-för-steg-guiderna, här är en jämförelse sida vid sida som jag önskar att jag hade innan jag började testa. Tabellen hjälper dig att välja rätt metod för din situation:

Om du vill lära dig grunderna i Python-scraping, börja med metod 1 eller 2. Om du behöver driftsäkerhet i produktion, välj metod 3. Om du vill ha resultat på två klick utan att skriva kod, hoppa direkt till metod 4.

Innan du börjar

• Svårighetsgrad: Nybörjare till medel (beroende på metod)
• Tidsåtgång: ~15 minuter för Thunderbit, ~45 minuter för Python-metoderna
• Det du behöver: Python 3.8+ (för metod 1–3), Chrome-webbläsare, (för metod 4) och en URL till en Amazon Best Sellers-kategori

Metod 1: Skrapa Amazon Best Sellers med requests + BeautifulSoup

Det här är den lätta, nybörjarvänliga metoden — ingen webbläsarautomatisering, bara HTTP-anrop och HTML-parsning. Den lärde mig också mest om Amazons skydd mot scraping.

Steg 1: Sätt upp din miljö

Installera nödvändiga paket:

1pip install requests beautifulsoup4 pandas

Sätt sedan upp dina imports:

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

Steg 2: Skicka en request med realistiska headers

Amazon blockerar förfrågningar som ser ut som botar. Det mest grundläggande skyddet är en User-Agent-header som efterliknar en riktig webbläsare. Här är ett exempel med en uppsättning aktuella, realistiska User-Agent-strängar (hämtade från , 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)  # Bör vara 200

Om du ser statuskod 200 är du inne. Om du får 503 eller blir omdirigerad till en CAPTCHA-sida har Amazon flaggat din begäran.

Steg 3: Parsar produktdata med BeautifulSoup

Inspektera Amazons HTML i webbläsarens DevTools (högerklicka → Inspect). Produktkorten använder ID:t gridItemRoot. Inuti varje kort hittar du produktnamn, pris, betyg och 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})

Varning: Klassnamnen med prefixet _cDEzb_ är CSS module-hashar som Amazon genererar om med jämna mellanrum. ID:t gridItemRoot och klassen a-link-normal är stabilare, men kontrollera alltid selectors i DevTools innan du kör din scraper.

Steg 4: Exportera till CSV

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

Vad du kan förvänta dig — och vad som går fel

I mitt test returnerade den här metoden ungefär 30 produkter istället för 50. Det är inte ett fel i koden — det är Amazons lazy loading. Bara omkring 30 produkter renderas vid första sidladdningen; resten visas efter scrollning, vilket kräver JavaScript-körning som requests inte klarar.

Andra begränsningar:

• IP-bans kommer snabbt utan proxyrotation (jag blev blockerad efter cirka 15 snabba requests)
• CSS-selectors går sönder när Amazon uppdaterar sidlayouten — och det gör de ofta
• Ingen inbyggd hantering av paginering

För att lära sig Python-scraping är den här metoden jättebra. För produktion är den skör.

Metod 2: Skrapa Amazon Best Sellers med Selenium

Selenium löser problemet med lazy loading genom att köra en riktig webbläsare — tyngre att sätta upp, men det fångar alla 50 produkter per sida.

Steg 1: Installera Selenium

1pip install selenium pandas

God nyhet: sedan Selenium 4.6+ behöver du inte längre webdriver-manager. Selenium Manager hanterar nedladdning av drivrutiner automatiskt.

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)

Flaggan --headless=new (introducerad i Chrome 109+) använder samma renderingsmotor som en vanlig Chrome, vilket gör det svårare för Amazon att upptäcka.

Steg 2: Scrolla förbi lazy loading

Det här är steget som gör Selenium värt den extra setupen. Amazon Best Sellers laddar bara ungefär 30 produkter i början — resten dyker upp efter att du scrollat.

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)

Efter scrollning bör alla 50 produkter vara renderade i DOM:en. Jag märkte att 5 Page Down-scrollningar med 2 sekunders paus räckte, men du kan behöva justera beroende på din anslutningshastighet.

Steg 3: Extrahera 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 är viktigt att kapsla in varje extraktion i try/except — vissa produkter kan vara slutsålda eller sakna fält, och du vill inte att ett trasigt element ska krascha hela körningen.

Steg 4: Hantera paginering

Amazon delar upp 100 Best Sellers över två sidor med olika 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    # ... extrahera produkter som ovan ...
11    all_products.extend(products)
12driver.quit()

Vad du kan förvänta dig

I mitt test fångade Selenium alla 50 produkter per sida — en tydlig seger över requests + BS4. Nackdelen: det tog ungefär 45 sekunder per sida (inklusive scrollfördröjningar), och jag blev fortfarande flaggad efter att ha kört det för många gånger utan proxyrotation. Selenium kan också upptäckas av Amazons bot-skydd även med anti-detekteringsflaggor — för seriös skala behöver du fler åtgärder (se Anti-Ban-spelplanen nedan).

Andra problem:

• Versioner av WebDriver kan fortfarande hamna i otakt ibland, även om Selenium Manager har gjort det mycket ovanligare
• CSS-selectors behöver uppdateras när Amazon ändrar sin DOM
• Minnesanvändningen är hög — varje webbläsarinstans äter 200–400 MB RAM

Metod 3: Skrapa Amazon Best Sellers med ett scraping-API

Scraping-API:er är metoden för dig som tänker "låt någon annan ta hand om det svåra." Tjänster som Scrape.do, Oxylabs och ScrapingBee hanterar proxyrotation, JavaScript-rendering och anti-bot-skydd — du skickar bara en URL och får tillbaka HTML eller JSON.

Så fungerar det

Du skickar din måladress till API-endpointen. API:t renderar sidan med en riktig webbläsare i sin infrastruktur, roterar proxies, hanterar CAPTCHA och returnerar ren HTML. Sedan parsar du HTML:en med BeautifulSoup som vanligt.

Steg 1: Skicka en request via API:t

Här är ett exempel med Scrape.do (priset börjar på $29/månad för 150 000 credits, där 1 credit = 1 request oavsett 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")

Härifrån är parsningen identisk med metod 1 — samma selectors, samma extraktionslogik.

Prischeck i verkligheten

Här är vad de stora API-tjänsterna tar per 1 000 Amazon-begäranden vid bästa tillgängliga prisnivå:

För- och nackdelar

Fördelar: Hög driftsäkerhet ( på Amazon hos de främsta leverantörerna), inget drivrutin-underhåll, hanterar anti-bot automatiskt, skalbart.

Nackdelar: Betalar per request (kostnaderna växer snabbt vid skala), du måste fortfarande skriva parsingskod, och du är fortfarande sårbar för ändringar i CSS-selectors. För 100 000 sidor per månad blir den totala kostnadsbilden dramatisk: att bygga internt kostar ungefär — en besparing på 71 %.

Brytpunkten ligger oftast runt 500K–1M requests per månad. Under den nivån väger tidsbesparingen med API:t betydligt tyngre än kostnaden.

Metod 4: Skrapa Amazon Best Sellers med Thunderbit (utan Python)

Full transparens: jag jobbar på Thunderbit, så ta den här delen med den kontexten. Men jag testade verkligen alla fyra metoderna direkt efter varandra, och skillnaden i tid till data var slående.

är en AI-webbskrapare som körs som ett Chrome-tillägg. Grundidén är enkel: i stället för att skriva CSS-selectors eller Python-kod läser AI:n sidan och räknar ut vilken data som ska extraheras. För just Amazon Best Sellers finns det färdiga mallar som fungerar med ett klick.

Steg 1: Installera Thunderbit Chrome Extension

Gå till och klicka på "Add to Chrome." Skapa ett gratis konto — gratisnivån ger dig tillräckligt med credits för att testa detta.

Steg 2: Öppna Amazon Best Sellers-sidan

Öppna valfri kategori-sida för Amazon Best Sellers i Chrome. Till exempel: https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/

Steg 3: Klicka på "AI Suggest Fields"

Öppna Thunderbit-sidopanelen och klicka på "AI Suggest Fields." AI:n analyserar sidans struktur och föreslår kolumner: produktnamn, pris, betyg, bild-URL, säljare, produkt-URL och rank. I mitt test identifierade den alla relevanta fält på ungefär 3 sekunder.

Du kan byta namn på, ta bort eller lägga till kolumner. Du kan till och med lägga till egna AI-promptar per fält — till exempel "kategorisera som Electronics/Apparel/Home" för att lägga till en kategoritagg på varje produkt.

Steg 4: Klicka på "Scrape"

Tryck på "Scrape". Thunderbit fyller en strukturerad tabell med all produktdata från sidan. I molnläge kan det bearbeta upp till 50 sidor samtidigt i parallell, och hanterar lazy loading och paginering automatiskt.

Steg 5: Exportera gratis

Klicka på "Export" och välj destination: Excel, Google Sheets, Airtable eller Notion. Alla exporter är gratis på alla planer — inga dolda avgifter.

Hela processen tog mig ungefär 90 sekunder från att jag öppnade sidan till att jag hade ett komplett kalkylblad. Som jämförelse tog metod 1 ungefär 20 minuter (inklusive felsökning av lazy loading), metod 2 tog ungefär 35 minuter (inklusive Selenium-setup) och metod 3 tog ungefär 15 minuter (inklusive konto för API:t).

Varför Thunderbit fungerar så bra med Amazon

Eftersom AI:n läser sidan på nytt varje gång anpassar den sig automatiskt till layoutändringar — inga CSS-selectors att underhålla. Det här löser direkt det vanligaste klagomålet i scraping-forum: "En grundläggande web scraper räcker inte, du måste lägga till massor av 'fällor' för elementförändringar." När Amazon ändrar sin DOM (vilket händer regelbundet) behöver du inte uppdatera någonting.

Molnbaserat scraping-läge hanterar proxyrotation, rendering och anti-bot-skydd transparent. För användare som vill ha en lösning som bara fungerar eliminerar det hela anti-ban-huvudvärken.

Anti-Ban-spelplanen: Så undviker du att blockeras av Amazon

Amazons bot-detektering är aggressiv. Jag fick min IP tillfälligt blockerad under testet, och användare på forum rapporterar samma sak: "fel överallt, amazon började till och med omdirigera mig till startsidan." Om du kör Python-spåret (metod 1–3) är det här avsnittet avgörande.

Här är en lager-på-lager-strategi, från enkel till avancerad:

1. Rotera User-Agent-strängar

Att skicka samma User-Agent om och om igen är en varningssignal. Använd uppsättningen med 5+ strängar från kodexemplet i metod 1 och välj slumpmässigt en per request:

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

2. Lägg in slumpmässiga fördröjningar mellan requests

Fasta fördröjningar är lätta att upptäcka (mönster). Slumpmässiga är säkrare:

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

Jag märkte att 2–5 sekunder mellan requests höll mig under radarn för små batcher (under 50 requests). För större körningar, öka till 3–7 sekunder.

3. Använd proxyrotation

Det här är den stora grejen. visar att residential proxies i snitt ligger på cirka 94 % lyckande på Amazon, jämfört med cirka 59 % för datacenter-proxies — en skillnad på 35 procentenheter. Amazons detekteringsstack inkluderar TLS-fingeravtryck, beteendeanalys och hastighetsbegränsning per IP, så vanliga datacenter-IP:er flaggas inom sekunder.

Residential proxies är dyrare ($2–$12 per GB beroende på leverantör) men mycket mer pålitliga. Exempel:

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. Härda webbläsarens fingeravtryck (Selenium)

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

5. Hantera sessioner och cookies

Att behålla cookies mellan requests gör att din scraper ser mer ut som en riktig användarsession:

1session = requests.Session()
2# Besök startsidan först för att få realistiska cookies
3session.get("https://www.amazon.com", headers=headers)
4time.sleep(2)
5# Skrapa sedan målsidan
6response = session.get(target_url, headers=headers)

6. När du bör hoppa över huvudvärken helt

För användare som inte vill hantera något av detta sköter Thunderbits molnskrapning proxyrotation, rendering och anti-bot-skydd automatiskt. Scraping-API:er hanterar också det mesta av detta direkt. Enligt min erfarenhet överstiger tiden som går åt till att felsöka anti-ban-problem ofta tiden du faktiskt lägger på att skriva scraping-koden — så lösningen som bara fungerar har verklig ROI.

Berikning av undersidor: Skrapa produktdetaljsidor för rikare data

Best Sellers-listan visar bara grundläggande information — titel, pris, betyg, rank. Men det verkliga värdet för FBA-research finns på enskilda produktsidor. Här är vad du missar om du bara skrapar listan:

Fältet "Date First Available" är särskilt värdefullt — det visar hur länge produkten har funnits på marknaden, vilket är en viktig signal i konkurrensanalys. Och om du vet antalet säljare och vem som äger Buy Box kan du bättre avgöra om en produktnisch är värd att gå in i (om Amazon själv har över 30 % av Buy Box-andelen är det extremt svårt att konkurrera).

Python-metod: Loopa igenom produkt-URL:er

Efter att ha samlat in produkt-URL:er från listningssidan loopar du igenom varje sida med en fördröjning:

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    # Extrahera varumärke
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    # Extrahera ASIN från sidkällan eller URL:en
9    # Extrahera Date First Available från produktsidans informationstabell
10    # ... ytterligare fält ...

Varning: att träffa 100 enskilda produktsidor ökar risken för blockering markant. Räkna med proxyrotation och längre fördröjningar.

Thunderbit-metod: Subpage-skrapning med ett klick

Efter att ha skrapat listningssidan till en tabell klickar du på "Scrape Subpages" i Thunderbit. AI:n besöker då varje produkt-URL och berikar tabellen med ytterligare kolumner — varumärke, ASIN, specifikationer, funktioner — automatiskt. Ingen extra kod, inga selectors, ingen setup. Det här är särskilt användbart för e-handelsteam som behöver helhetsbilden för inköpsbeslut men inte vill skriva och underhålla en parser för produktsidor.

Automatisera återkommande skrapningar: Bevaka Best Sellers över tid

En engångsskrapning är användbar, men löpande bevakning är där den verkliga konkurrensfördelen finns. Att följa vilka produkter som stiger och faller, upptäcka trender tidigt och följa prisförändringar över veckor eller månader — det är det som skiljer tillfällig research från datadrivna beslut.

Python-metod: Schemalägg med Cron

På Linux/Mac kan du schemalägga ditt Python-skript med cron. Här är en crontab-rad för en daglig körning kl. 08:00:

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

För en veckovis körning på måndagar kl. 09:00:

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

På Windows använder du Task Scheduler för att göra samma sak. För schemaläggning som alltid är igång utan att din laptop måste vara på, kan du köra på en VPS eller AWS Lambda — men det ökar komplexiteten i infrastrukturen.

Lägg till loggning och felnotiser för att fånga misslyckade körningar. Det finns inget värre än att upptäcka att din scraper i tysthet gick sönder för två veckor sedan.

Thunderbit-metod: Scheduled Scraper i vanlig svenska

Thunderbits Scheduled Scraper låter dig beskriva intervallet med naturligt språk — skriv "varje måndag kl. 9" eller "varje dag kl. 8" så tolkar AI:n schemat. Skrapningar körs på Thunderbits molnservrar (ingen webbläsare eller dator behöver vara igång), och datan exporteras automatiskt till Google Sheets eller Airtable. Det skapar en live-dashboard för bevakning utan serveradministration — perfekt för operations-team som vill ha löpande insyn utan DevOps-bördor.

Juridiska och etiska överväganden när du skrapar Amazon

Jag är inte jurist, och detta är inte juridisk rådgivning. Men att ignorera det juridiska landskapet i en scraping-guide vore oansvarigt — användare på forum lyfter uttryckligen frågor om ToS, och med god anledning.

Amazons robots.txt: Per 2026 innehåller Amazons robots.txt över 80 specifika Disallow-sökvägar, men /gp/bestsellers/ är INTE uttryckligen blockerad för vanliga user agents. Däremot får över 35 AI-specifika user agents (ClaudeBot, GPTBot, Scrapy m.fl.) ett generellt Disallow: /. Att något inte är uttryckligen förbjudet betyder inte att Amazon godkänner scraping.

Amazons användarvillkor: Amazons (uppdaterade maj 2025) förbjuder uttryckligen att man använder "any automated process or technology to access, acquire, copy, or monitor any part of the Amazon Website" utan skriftligt tillstånd. Det här är inte teoretiskt — Amazon i november 2025 för otillåten automatiserad åtkomst och vann ett preliminärt föreläggande.

Prejudikatet hiQ v. LinkedIn: I (Ninth Circuit, 2022) slog domstolen fast att scraping av offentligt tillgänglig data sannolikt inte bryter mot Computer Fraud and Abuse Act. Men hiQ nådde till slut en förlikning och gick med på att sluta skrapa — att vinna enligt CFAA skyddar inte mot avtalsbrott.

Praktiska riktlinjer:

• Skrapa bara offentligt tillgänglig data (priser, BSR, produkttitlar — inte personuppgifter)
• Respektera hastighetsgränser och överbelasta inte servrar
• Använd datan för legitim konkurrensanalys
• Rådfråga egen jurist innan du skalar upp scraping
• Var medveten om att nu har omfattande integritetslagstiftning

Thunderbits molnskrapning använder vanliga webbläsarliknande request-mönster, men du bör alltid kontrollera efterlevnad med din egen jurist.

Vilken metod ska du välja? En snabb beslutsguide

Kort version:

• "Jag lär mig Python och vill ha ett helgprojekt." → Metod 1 (requests + BeautifulSoup). Du lär dig massor om HTTP-begäranden, HTML-parsning och Amazons anti-bot-skydd.
• "Jag behöver skrapa JavaScript-tunga sidor eller inloggade sessioner." → Metod 2 (Selenium). Tyngre, men hanterar dynamiskt innehåll.
• "Jag kör produktion i stor skala." → Metod 3 (Scraping API). Låt någon annan sköta proxies och rendering. talar för API:er under 500K requests/månad.
• "Jag är inte utvecklare och vill ha data på 2 minuter." → Metod 4 (). Ingen kod, inga selectors, inget underhåll.
• "Jag behöver löpande bevakning utan serverhantering." → Thunderbit Scheduled Scraper. Ställ in det en gång och låt det rulla.

Slutsats och viktigaste lärdomar

Efter en helg av tester fastnade det här verkligen:

requests + BeautifulSoup är bra för lärande, men begränsningen med lazy loading (bara cirka 30 av 50 produkter) och sköra CSS-selectors gör det opraktiskt för produktion.

Selenium löser lazy-loading-problemet och fångar alla 50 produkter per sida, men det är långsamt, minneskrävande och fortfarande möjligt för Amazon att upptäcka.

Scraping API:er erbjuder bäst tillförlitlighet för skrapning i produktion — på Amazon — men kostnaderna växer och du måste fortfarande skriva parsingskod.

Thunderbit levererade snabbast tid till data med stor marginal. AI:n hanterar layoutändringar, lazy loading, paginering och anti-bot-skydd utan någon konfiguration. För icke-tekniska användare eller team som behöver återkommande data utan DevOps-overhead är det det mest praktiska alternativet.

Den största lärdomen? Amazons anti-bot-skydd och täta layoutändringar gör att underhållsfria lösningar sparar mest tid i längden. Varje timme du lägger på att felsöka trasiga selectors och rotera proxies är en timme du inte lägger på faktisk analys.

Vill du testa det kodfria sättet? ger dig tillräckligt med credits för att skrapa några Best Sellers-kategorier och se resultatet själv. Föredrar du Python-spåret? Kodexemplen ovan borde få dig igång. Oavsett vilket får du Amazon Best Seller-data i ett kalkylblad i stället för att stirra på en webbläsarflik.

För mer om olika sätt att skrapa webben, kolla in våra guider om , och . Du kan också se steg-för-steg-genomgångar på .

Läs mer