Om du har följt en Amazon-scrapingguide och ändå kört rakt in i en vägg av CAPTCHAs, 503-fel eller helt tomma resultat — då är du långt ifrån ensam. Många av de Python-guider för Amazon som cirkulerar på nätet skrevs 2022 eller 2023, och de bygger på selectors och metoder som Amazon för länge sedan har hunnit täppa till.
Jag har lagt flera år på att bygga verktyg för datainsamling på Thunderbit, och en sak kan jag säga direkt: Amazon är en av de tuffaste sajterna att skrapa på ett tillförlitligt sätt. Plattformen ändrar sin HTML-struktur hela tiden, använder ett sexlagers skydd mot bottar och visar dessutom olika sidlayouter för olika användare genom A/B-testning. I den här guiden går jag igenom en Python-baserad Amazon-scraper som faktiskt fungerar 2025 — med verifierade CSS-selectors, en flerskiktad strategi mot blockering och råd om schemaläggning och export som de flesta guider helt hoppar över. Och för dig som bara vill åt datan utan att brottas med Python visar jag också hur Thunderbit kan göra samma jobb på ungefär två klick.
Vad är Amazon-produkt-scraping?
Amazon-produkt-scraping innebär att man programmässigt hämtar offentligt tillgänglig data — produktnamn, priser, betyg, antal recensioner, bilder, lagersaldo med mera — från Amazons produkt- och sökresultatsidor. I stället för att manuellt kopiera information från hundratals listningar låter du en scraper besöka varje sida, läsa HTML-koden och plocka ut den data du vill ha till ett strukturerat format som CSV, Excel eller en databas.
Tänk dig att du anställer en outtröttlig praktikant som hinner besöka tusen produktsidor på samma tid som det tar dig att dricka ditt morgonkaffe. Skillnaden är att den här praktikanten aldrig stavar fel och aldrig behöver lunchrast.
Varför skrapa Amazon-produkter med Python?
Amazon har ungefär 350–600 miljoner produktlistningar inom fler än 30 kategorier, drivna av omkring 9,7 miljoner säljar-konton. Försäljning från tredjepart står nu för 69 % av den totala GMV:n. Det är omöjligt att övervaka ens en liten del av katalogen manuellt. Här är varför team skrapar Amazon:
| Användningsområde | Vem gynnas | Vad de extraherar |
|---|---|---|
| Prisövervakning och reprissättning | E-handelsdrift, marknadsplats-säljare | Priser, tillgänglighet, säljarinformation |
| Konkurrentanalys | Produktchefer, varumärkesteam | Produktfunktioner, betyg, antal recensioner |
| Marknadsanalys | Analytiker, team för nya produkter | Trender i kategorier, prisfördelning |
| Leadgenerering | Säljteam | Säljar-namn, varumärkesinfo, kontaktdata |
| Affiliate-marknadsföring | Innehållsskapare, dealsajter | Priser, erbjudanden, produktdetaljer |
| Lageruppföljning | Supply chain, inköp | Lagersaldo, leveransuppskattningar |
Amazons prissättning i sig gör automatisering nödvändig: Amazon ändrar priser mer än 2,5 miljoner gånger per dag, och en genomsnittlig produkt uppdateras ungefär var tionde minut. Till skillnad från detta ändrar konkurrenter som Best Buy och Walmart priser bara runt 50 000 gånger per månad. Inget mänskligt team kan hinna med det.
Python ger dig full kontroll över scrapingprocessen — du bestämmer vad som ska extraheras, hur fel ska hanteras och var datan ska sparas. Men det betyder också att du själv ansvarar för underhåll, skydd mot blockeringar och att hålla jämna steg med Amazons frekventa HTML-förändringar.
Vad du kan skrapa från Amazon (och vad du inte kan)
Från offentligt tillgängliga produktsidor kan du vanligtvis extrahera:
- Produkttitel (namn, varumärke)
- Pris (aktuellt pris, ordinarie pris, kampanjpris)
- Betyg (genomsnittliga stjärnor)
- Antal recensioner
- Produktbilder (huvudbildens URL)
- Tillgänglighet / lagersaldo
- ASIN (Amazon Standard Identification Number)
- Produktbeskrivning och punktlistor
- Säljarinformation
- Produktvarianter (storlek, färg osv.)
Det du bör undvika:
- Data bakom inloggning: utökade recensionssidor, personliga kontodata, orderhistorik
- Personuppgifter: köparnamn, adresser, betalningsinformation
- Skyddat innehåll för återpublicering: produktbeskrivningar och bilder går bra för analys, men publicera dem inte som ditt eget material
Amazons robots.txt blockerar 50+ namngivna bottar (inklusive GPTBot, Scrapy och ClaudeBot) och förbjuder sökvägar som användarkonton, kundvagnar och önskelistor. Produktsidor är inte uttryckligen förbjudna, men Amazons användarvillkor tillåter inte automatiserad åtkomst. Domstolar har i regel skiljt mellan brott mot användarvillkor (civilrättsligt) och straffrättsliga överträdelser enligt CFAA — mer om detta längst ned i guiden.
Verktyg och bibliotek du behöver
Här är Python-stacken för den här guiden:
| Bibliotek | Syfte | Varför vi använder det |
|---|---|---|
requests | HTTP-förfrågningar | Enkelt och välstött |
beautifulsoup4 | HTML-parsning | Lätt att extrahera med CSS-selectors |
lxml | Snabb HTML-parser | Används som parser-backend för BeautifulSoup |
curl_cffi | TLS-fingerprint-efterlikning | Avgörande för att kringgå Amazons upptäckt |
pandas | Datastrukturering och export | DataFrames, export till CSV/Excel |
Valfritt (för innehåll som renderas med JavaScript):
seleniumellerplaywright— headless webbläsarautomatisering
Så här sätter du upp din Python-miljö
Öppna terminalen och kör:
mkdir amazon-scraper && cd amazon-scraper
python -m venv venv
source venv/bin/activate # På Windows: venv\Scripts\activate
pip install requests beautifulsoup4 lxml curl_cffi pandas
Kontrollera att allt installerats:
import requests, bs4, curl_cffi, pandas
print("All good!")
Om du ser "All good!" utan fel är du redo.
Varför de flesta Amazon-scrapingguider går sönder (och varför den här är annorlunda)
Det här är delen som de flesta guider hoppar över, och det är också anledningen till att du troligen läser den här artikeln.
Amazon uppdaterar ofta sin HTML-struktur, sina klassnamn och element-ID:n. Scraping-communityn rapporterar att 10–15 % av crawlers behöver veckovisa fixar på grund av förändringar i DOM och fingeravtrycksteknik. Den mest ökända kraschpunkten? Selectorn #priceblock_ourprice, som dök upp i hundratals guider från 2018–2023. Det ID:t finns inte längre på Amazons produktsidor.
En snabb jämförelse av vad som är trasigt kontra vad som fungerar nu:
| Datapunkt | Trasig selector (före 2024) | Fungerande selector 2025 |
|---|---|---|
| Pris | #priceblock_ourprice | div#corePriceDisplay_desktop_feature_div span.a-price .a-offscreen |
| Titel | #productTitle | span#productTitle (fungerar fortfarande) |
| Betyg | span.a-icon-alt (ibland fel sammanhang) | #acrPopover span.a-icon-alt |
| Antal recensioner | #acrCustomerReviewCount | span#acrCustomerReviewText |
| Tillgänglighet | #availability span | div#availability span.a-size-medium |
Varje kodexempel i den här guiden har testats mot live-sidor på Amazon under 2025. Jag visar de faktiska CSS-selectors tillsammans med förväntad output — inget återanvänt material från 2022.
Innan du börjar
- Svårighetsgrad: Medel (grundläggande Python-kunskaper antas)
- Tidsåtgång: Cirka 30–45 minuter för hela guiden; cirka 10 minuter för den grundläggande scrapen
- Det du behöver: Python 3.9+, Chrome-webbläsare (för att inspektera Amazon-sidor), en terminal och eventuellt Thunderbit Chrome Extension om du vill jämföra med no-code-metoden
Steg 1: Skicka din första förfrågan till Amazon
Öppna valfri Amazon-produktsida i webbläsaren och kopiera URL:en. Vi börjar med en enkel requests.get():
import requests
url = "https://www.amazon.com/dp/B0DGNFM9YJ"
response = requests.get(url)
print(response.status_code)
print(response.text[:500])
Kör detta, och du kommer nästan säkert att få en 503-statuskod eller en sida som säger "To discuss automated access to Amazon data please contact…". Det är Amazons WAF (Web Application Firewall) som upptäcker ditt Python-skript. En naken requests.get() utan rätt headers ger bara ungefär 2 % träffsäkerhet mot Amazon.
Du bör se något i stil med: 503 och en block-sida i HTML:en. Det är väntat — vi löser det i nästa steg.
Steg 2: Sätt upp egna headers och TLS-efterlikning
Att bara lägga till en User-Agent räcker inte längre. Amazon jämför dina HTTP-headers med ditt TLS-fingerprint. Om du påstår att du är Chrome 120 men TLS-handshaken avslöjar Python-biblioteket requests, blir du direkt markerad.
Det mest pålitliga tillvägagångssättet 2025 är att använda curl_cffi med webbläsar-efterlikning:
from curl_cffi import requests as cfreq
headers = {
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
"Accept-Language": "en-US,en;q=0.9",
"Accept-Encoding": "gzip, deflate, br",
"Referer": "https://www.google.com/",
"DNT": "1",
"Connection": "keep-alive",
"Upgrade-Insecure-Requests": "1",
}
url = "https://www.amazon.com/dp/B0DGNFM9YJ"
response = cfreq.get(url, headers=headers, impersonate="chrome124")
print(response.status_code)
print(len(response.text))
Med curl_cffi som efterliknar Chrome 124 ökar träffsäkerheten till cirka 94 % — en 47x förbättring jämfört med vanlig requests. Du bör nu se en 200-statuskod och en mycket längre HTML-svarstext (över 100 000 tecken).
Om du fortfarande får 503, prova ett annat impersonate-värde (t.ex. "chrome131") eller vänta lite innan du försöker igen.
Steg 3: Parsa HTML och extrahera produktdata
Nu när vi har full HTML kan vi extrahera data med BeautifulSoup och verifierade 2025-selectors:
from bs4 import BeautifulSoup
soup = BeautifulSoup(response.text, "lxml")
# Produkttitel
title_el = soup.select_one("span#productTitle")
title = title_el.get_text(strip=True) if title_el else None
# Pris
price_el = soup.select_one(
"div#corePriceDisplay_desktop_feature_div span.a-price .a-offscreen"
)
if not price_el:
price_el = soup.select_one("span.priceToPay .a-offscreen")
if not price_el:
price_el = soup.select_one(".apexPriceToPay .a-offscreen")
price = price_el.get_text(strip=True) if price_el else None
# Betyg
rating_el = soup.select_one("#acrPopover span.a-icon-alt")
rating = rating_el.get_text(strip=True) if rating_el else None
# Antal recensioner
reviews_el = soup.select_one("span#acrCustomerReviewText")
reviews = reviews_el.get_text(strip=True) if reviews_el else None
# Tillgänglighet
avail_el = soup.select_one("div#availability span")
availability = avail_el.get_text(strip=True) if avail_el else None
# Huvudbildens URL
img_el = soup.select_one("#landingImage")
image_url = img_el.get("src") if img_el else None
print(f"Title: {title}")
print(f"Price: {price}")
print(f"Rating: {rating}")
print(f"Reviews: {reviews}")
print(f"Availability: {availability}")
print(f"Image: {image_url}")
Förväntad output (exempel):
Title: Apple AirPods Pro (2nd Generation) with USB-C
Price: $189.99
Rating: 4.7 out of 5 stars
Reviews: 98,432 ratings
Availability: In Stock
Image: https://m.media-amazon.com/images/I/61SUj2...
Notera de flera reserv-selectors för priset — Amazon använder olika behållare beroende på produkttyp, kampanjstatus och A/B-testvariant. Genom att lägga varje extrahering i en villkorskontroll undviker du att scrapen kraschar när en selector inte matchar.
Steg 4: Skrapa flera produkter från sökresultat
För att bygga en riktig dataset vill du börja från en Amazons sökresultatsida, samla ASIN:er och sedan skrapa varje produkts detaljsida.
import time
import random
def get_search_asins(keyword, max_pages=1):
"""Samla ASIN:er från Amazons sökresultat."""
asins = []
for page in range(1, max_pages + 1):
search_url = f"https://www.amazon.com/s?k={keyword}&page={page}"
resp = cfreq.get(search_url, headers=headers, impersonate="chrome124")
if resp.status_code != 200:
print(f"Sökresultatssida {page} returnerade {resp.status_code}")
break
search_soup = BeautifulSoup(resp.text, "lxml")
results = search_soup.select('div[data-component-type="s-search-result"]')
for r in results:
asin = r.get("data-asin")
if asin:
asins.append(asin)
print(f"Sida {page}: hittade {len(results)} produkter")
time.sleep(random.uniform(2, 5)) # Hänsynsfull fördröjning
return asins
asins = get_search_asins("wireless+earbuds", max_pages=2)
print(f"Samlade {len(asins)} ASIN:er")
Varje ASIN motsvarar en ren produkt-URL: https://www.amazon.com/dp/{ASIN}. Det är mer tillförlitligt än att använda hela sökresultat-URL:er, som kan innehålla sessionsspecifika parametrar.
Steg 5: Hantera paginering och skrapa i skala
Låt oss nu kombinera insamling från sök och scraping av detaljsidor till en full pipeline:
import pandas as pd
def scrape_product(asin):
"""Skrapa en enskild Amazons detaljsida för en produkt."""
url = f"https://www.amazon.com/dp/{asin}"
try:
resp = cfreq.get(url, headers=headers, impersonate="chrome124")
if resp.status_code != 200:
return None
soup = BeautifulSoup(resp.text, "lxml")
title_el = soup.select_one("span#productTitle")
price_el = (
soup.select_one("div#corePriceDisplay_desktop_feature_div span.a-price .a-offscreen")
or soup.select_one("span.priceToPay .a-offscreen")
or soup.select_one(".apexPriceToPay .a-offscreen")
)
rating_el = soup.select_one("#acrPopover span.a-icon-alt")
reviews_el = soup.select_one("span#acrCustomerReviewText")
avail_el = soup.select_one("div#availability span")
img_el = soup.select_one("#landingImage")
return {
"asin": asin,
"title": title_el.get_text(strip=True) if title_el else None,
"price": price_el.get_text(strip=True) if price_el else None,
"rating": rating_el.get_text(strip=True) if rating_el else None,
"reviews": reviews_el.get_text(strip=True) if reviews_el else None,
"availability": avail_el.get_text(strip=True) if avail_el else None,
"image_url": img_el.get("src") if img_el else None,
"url": url,
}
except Exception as e:
print(f"Fel vid scraping av {asin}: {e}")
return None
# Skrapa alla insamlade ASIN:er
products = []
for i, asin in enumerate(asins):
print(f"Skrapar {i+1}/{len(asins)}: {asin}")
product = scrape_product(asin)
if product:
products.append(product)
time.sleep(random.uniform(2, 5)) # Slumpmässig paus mellan förfrågningar
df = pd.DataFrame(products)
print(f"\nSkrapade {len(df)} produkter utan fel")
print(df.head())
Den slumpmässiga fördröjningen på 2–5 sekunder är avgörande. Perfekt regelbunden timing (t.ex. exakt 3 sekunder varje gång) ser misstänkt ut för Amazons beteendeanalys. Slumpade intervaller efterliknar mänskligt surfmönster.
Steg 6: Spara skrapad Amazon-data som CSV
df.to_csv("amazon_products.csv", index=False, encoding="utf-8-sig")
print("Sparat till amazon_products.csv")
Nu bör du ha en ren CSV med kolumner för ASIN, titel, pris, betyg, recensioner, tillgänglighet, bild-URL och produkt-URL. Det är här de flesta guider slutar — men om du bygger ett riktigt arbetsflöde är CSV bara början.
Djupdykning i anti-blockering: Så håller du din scraper igång
Att bli blockerad är det största problemet för alla som försöker skrapa Amazon-produkter med Python. Amazons sexlagersförsvar består av IP-reputationsanalys, TLS-fingerprinting, kontroll av webbläsarmiljö, beteendebiometri, CAPTCHAs och ML-baserad avvikelsedetektion. Nedan följer en lager-på-lager-strategi för att hantera varje del.
Rotera User-Agents och fullständiga headers
En enda statisk User-Agent flaggas snabbt. Rotera mellan en lista med aktuella webbläsarsträngar:
import random
USER_AGENTS = [
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36",
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36",
"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0",
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Safari/605.1.15",
]
def get_headers():
return {
"User-Agent": random.choice(USER_AGENTS),
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
"Accept-Language": "en-US,en;q=0.9",
"Accept-Encoding": "gzip, deflate, br",
"Referer": "https://www.google.com/",
"DNT": "1",
"Connection": "keep-alive",
}
En detalj som ofta ställer till det: din Accept-Language måste matcha den geografiska plats som din IP-adress antyder. Att skicka Accept-Language: en-US från en tysk IP-adress är en tydlig varningssignal.
TLS-fingerprint-efterlikning med curl_cffi
Vi tog upp detta i steg 2, men det är värt att betona: den här enskilda tekniken ger den största ökningen i träffsäkerhet. Vanlig Python requests når ungefär 2 % framgång mot Amazon. Med curl_cffi-efterlikning hamnar du runt 94 %. Det är skillnaden mellan en fungerande scraper och en trasig.
from curl_cffi import requests as cfreq
# Rotera även mellan olika impersonation-mål
BROWSERS = ["chrome120", "chrome124", "chrome131"]
response = cfreq.get(
url,
headers=get_headers(),
impersonate=random.choice(BROWSERS),
)
Proxy-rotation
För att skrapa mer än ett fåtal sidor behöver du proxy-rotation. Amazon spårar IP-adresser och blockerar alla enskilda IP:n som skickar för många förfrågningar.
PROXIES = [
"http://user:pass@proxy1.example.com:8080",
"http://user:pass@proxy2.example.com:8080",
"http://user:pass@proxy3.example.com:8080",
]
proxy = random.choice(PROXIES)
response = cfreq.get(
url,
headers=get_headers(),
impersonate="chrome124",
proxies={"http": proxy, "https": proxy},
)
Residential proxies är effektivare än datacenter-proxies (Amazon blockerar proaktivt IP-intervall från datacenter), men de är också dyrare. För ett mindre projekt kan du börja med en betald proxytjänst och skala upp vid behov.
Hastighetsbegränsning och exponentiell backoff
Ingen konkurrerande artikel jag hittat tar upp detta, men det är avgörande. När du får ett 503-svar eller en CAPTCHA, försök inte bara igen direkt — det är ett snabbt sätt att bli permanent blockerad.
import time
import random
def fetch_with_backoff(url, max_retries=3):
"""Hämta en URL med exponentiell backoff vid fel."""
for attempt in range(max_retries):
response = cfreq.get(
url,
headers=get_headers(),
impersonate=random.choice(BROWSERS),
)
if response.status_code == 200:
return response
# Exponentiell backoff med slumpmoment
wait = min(2 ** attempt + random.uniform(0, 1), 30)
print(f"Försök {attempt+1} misslyckades ({response.status_code}). Väntar {wait:.1f}s...")
time.sleep(wait)
return None # Alla försök förbrukade
Formeln wait = min(2^attempt + jitter, max_delay) säkerställer att dina pauser växer (2s, 4s, 8s...) men aldrig blir orimligt långa. Den slumpmässiga variationen förhindrar att ditt återförsöksmönster går att fingeravtrycka.
Selenium- eller Playwright-fallback för innehåll som renderas med JavaScript
Vissa Amazon-sidor (särskilt de med dynamiska priswidgets eller variantväljare) kräver JavaScript för att renderas helt. När curl_cffi ger ofullständig HTML är en headless webbläsare din reservlösning:
from playwright.sync_api import sync_playwright
def scrape_with_browser(url):
with sync_playwright() as p:
browser = p.chromium.launch(headless=True)
page = browser.new_page()
page.goto(url, wait_until="domcontentloaded")
page.wait_for_timeout(3000) # Låt JS rendera
html = page.content()
browser.close()
return html
Det här är långsammare — 3–5 sekunder per sida jämfört med under 1 sekund med curl_cffi. Använd det bara när det verkligen behövs.
Enligt min erfarenhet klarar curl_cffi över 90 % av Amazons produktsidor utan webbläsare.
Sammanfattning av anti-blockering
| Teknik | Svårighetsgrad | Effektivitet | Täcks av de flesta guider? |
|---|---|---|---|
| Egen User-Agent | Lätt | Låg (Amazon upptäcker mönster) | Ja |
| Full header-rotation | Lätt | Medel | Sällan |
| TLS-efterlikning (curl_cffi) | Medel | Hög (~94 % träffsäkerhet) | Nästan aldrig |
| Proxy-rotation | Medel | Hög | I bästa fall kortfattat |
| Hastighetsbegränsning + exponentiell backoff | Lätt | Medel | Nej |
| Selenium/Playwright-fallback | Medel | Hög (för JS-innehåll) | Nämns, men demonstreras inte |
Mer än CSV: Exportera skrapad Amazon-data till Google Sheets, Airtable och mer
Varje guide jag granskade stannar vid CSV-export. Men riktiga affärsflöden behöver datan i Google Sheets, databaser eller verktyg som Airtable och Notion.
Exportera till Google Sheets med gspread
Börja med att skapa ett Google-servicekonto (engångsinställning):
- Gå till Google Cloud Console → APIs & Services → Credentials
- Skapa ett servicekonto och ladda ned JSON-nyckelfilen
- Spara den till
~/.config/gspread/service_account.json - Dela ditt kalkylark med
client_emailfrån JSON-filen
Sedan:
import gspread
from gspread_dataframe import set_with_dataframe
gc = gspread.service_account()
sh = gc.open("Amazon Scrape Data")
worksheet = sh.sheet1
set_with_dataframe(worksheet, df)
print("Data exporterad till Google Sheets!")
Detta skriver hela din DataFrame direkt till ett Google Sheet — live, delbart och redo för dashboards.
Lagra i SQLite för lokal analys
För större dataset eller historisk spårning är SQLite perfekt — ingen server behövs, bara en enda fil:
import sqlite3
conn = sqlite3.connect("amazon_products.db")
df.to_sql("products", conn, if_exists="append", index=False)
print(f"Lagrade {len(df)} produkter i SQLite")
# Fråga senare:
historical = pd.read_sql_query(
"SELECT * FROM products WHERE price IS NOT NULL ORDER BY rowid DESC LIMIT 100",
conn,
)
No-code-alternativet
Om du inte vill underhålla Python-skript för export erbjuder Thunderbit gratis export till Google Sheets, Airtable, Notion, Excel, CSV och JSON — inklusive bildfält som visas direkt i Airtable och Notion. Ingen gspread-konfiguration, inga API-uppgifter, ingen kod alls. För team som vill få datan att flöda in i sina befintliga verktyg sparar det mycket tid.
Schemalägg automatiska Amazon-scrapes — kapitlet som saknas
Prisövervakning och lageruppföljning kräver återkommande scraping, inte engångskörningar. Ändå kunde jag inte hitta en enda konkurrentartikel som tar upp schemaläggning. Här är hur du automatiserar din Python-scraper.
Cron-jobb (Linux/macOS)
Öppna din crontab:
crontab -e
Lägg till en rad som kör din scraper varje dag klockan 06:00:
0 6 * * * cd /path/to/amazon-scraper && /path/to/venv/bin/python scraper.py >> ~/scraper.log 2>&1
Eller var sjätte timme:
0 */6 * * * cd /path/to/amazon-scraper && /path/to/venv/bin/python scraper.py >> ~/scraper.log 2>&1
Windows Task Scheduler
Skapa en batchfil run_scraper.bat:
@echo off
cd /d "C:\path\to\amazon-scraper"
call venv\Scripts\activate
python scraper.py
deactivate
Öppna sedan Task Scheduler → Create Basic Task → välj trigger (Daily, Hourly) → Action: "Start a program" → peka på run_scraper.bat.
GitHub Actions (gratisnivå)
För ett molnbaserat schema utan egen infrastruktur:
name: Amazon Scraper
on:
schedule:
- cron: "0 6 * * *" # Dagligen kl. 06:00 UTC
workflow_dispatch: # Manuell start
jobs:
scrape:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Set up Python
uses: actions/setup-python@v4
with:
python-version: "3.11"
- name: Install dependencies
run: pip install -r requirements.txt
- name: Run scraper
run: python scraper.py
- name: Commit results
run: |
git config user.name 'GitHub Actions'
git config user.email 'actions@github.com'
git add data/
git diff --staged --quiet || git commit -m "Uppdatera skrapad data"
git push
Lagra proxy-uppgifter i GitHub Secrets, så har du en gratis, automatiserad scraping-pipeline.
No-code-alternativ: Thunderbits Scheduled Scraper
För team som inte vill hantera cron-syntax eller molninfrastruktur erbjuder Thunderbit en inbyggd Scheduled Scraper. Du beskriver schemat i vanlig text (t.ex. "varje dag kl. 8" eller "varje måndag"), lägger till dina Amazon-URL:er och klickar på "Schemalägg". Ingen terminal, inga YAML-filer, ingen deploy-pipeline. Det är särskilt användbart för e-handels-team som övervakar priser eller lager kontinuerligt.
Python DIY vs. Scraper API vs. No-code: Vilken metod ska du välja?
Det här är en fråga jag ser hela tiden på forum, och ingen topprankad artikel ger ett strukturerat svar. Så här är min ärliga bedömning:
| Kriterium | Python + BS4/curl_cffi | Scraper API (ScraperAPI, Oxylabs) | No-code (Thunderbit) |
|---|---|---|---|
| Uppstartstid | 30–60 min | 10–20 min | ~2 minuter |
| Kod krävs | Ja (Python) | Ja (API-anrop) | Nej |
| Inbyggt skydd mot blockering | Nej (du bygger själv) | Ja | Ja |
| Klarar JS-rendering | Endast med Selenium/Playwright | Varierar beroende på leverantör | Ja (Browser- eller Cloud-läge) |
| Schemaläggning | Du bygger själv (cron/moln) | Vissa erbjuder det | Inbyggt |
| Kostnad | Gratis (+ proxykostnader) | 30–100+ USD/mån | Gratis nivå finns |
| Underhåll | Högt (selectors går sönder) | Lågt | Inget (AI anpassar sig) |
| Bäst för | Utvecklare som vill ha full kontroll | Skala och tillförlitlighet i volym | Snabbhet, icke-utvecklare, affärsanvändare |
Python är rätt val om du vill lära dig, anpassa varje detalj och inte har något emot löpande underhåll. Scraper API:er hanterar skydd mot blockering åt dig men kräver fortfarande kod. Och Thunderbit är den snabbaste vägen för sälj, e-handel eller vem som helst som bara vill ha datan — inga selectors, ingen kod, inget underhåll när Amazon ändrar sin HTML.
Så skrapar Thunderbit Amazon-produkter på 2 klick
Jag är förstås partisk — mitt team byggde det här. Men arbetsflödet är verkligen så här enkelt:
- Installera Thunderbit Chrome Extension
- Gå till en Amazon-sökresultatsida eller produktsida
- Klicka på "AI Suggest Fields" (eller använd den direkt färdiga Amazon-scraper-mallen)
- Klicka på "Scrape"
Thunderbits AI läser sidan, identifierar datastrukturen och extraherar allt till en ren tabell. Du kan exportera till Excel, Google Sheets, Airtable eller Notion gratis. Den verkliga vinsten: när Amazon ändrar sin HTML nästa vecka (och det kommer att hända), anpassar sig Thunderbits AI automatiskt. Inga trasiga skript, inga uppdateringar av selectors.
För att berika produktlistor med data från detaljsidor har Thunderbits funktion Subpage Scraping möjlighet att automatiskt följa länkar till produktsidor och hämta in extra fält som bilder, beskrivningar och varianter — något som kräver mycket extra kod i Python.
Tips för att din Python-baserade Amazon-scraper ska fungera långsiktigt
Om du väljer Python-spåret, så här minimerar du underhållsproblemen:
- Kontrollera selectors regelbundet. Amazon ändrar dem ofta. Boka in den här artikeln — jag uppdaterar selector-tabellen när saker förändras.
- Övervaka din träffsäkerhet. Följ andelen 200-svar kontra 503/CAPTCHA. Sätt upp en varning (även ett enkelt mejl) när träffsäkerheten sjunker under 80 %.
- Spara rå HTML. Spara hela HTML-svaret tillsammans med den parsade datan. Om selectors ändras kan du pars:a om historisk data utan att skrapa på nytt.
- Rotera proxies och User-Agents ofta. Statiska fingeravtryck flaggas inom timmar i större skala.
- Använd exponentiell backoff. Försök aldrig igen direkt efter en blockering.
- Kör i Docker. Packa in din scraper i en Docker-container för enklare driftsättning och portabilitet.
- Lägg till datavalidering. Kontrollera att priser är numeriska, att betyg ligger mellan 1–5 och att titlar inte är tomma. Ett team rapporterade 21 % färre fel längre ned i kedjan efter att de lagt till valideringslager.
Eller, om allt detta låter som mer jobb än du tänkt dig, fundera på om ett no-code-verktyg som Thunderbit passar bättre för ditt användningsfall. Det är inget att skämmas för att välja den snabbare vägen — jag har spenderat tillräckligt många år på att felsöka scrapers för att veta att ibland är den bästa koden den kod du slipper skriva.
Juridiska och etiska överväganden vid scraping av Amazon
Eftersom detta dyker upp i varje diskussion om Amazon-scraping, här är en snabb genomgång av det juridiska läget:
- Scraping av offentligt tillgänglig data är generellt lagligt i USA. Det vägledande avgörandet hiQ Labs v. LinkedIn (2022) slog fast att åtkomst till offentlig data inte bryter mot CFAA. Senare förstärkte Meta v. Bright Data (2024) och X v. Bright Data (2024) den principen.
- Amazons användarvillkor förbjuder automatiserad åtkomst. Detta är en civilrättslig fråga (avtalsbrott), inte ett straffrättsligt brott. Domstolar har i regel skiljt mellan dessa två.
- Amazon v. Perplexity (2025) är ett pågående mål som gäller AI-scraping av Amazons sidor. Ett preliminärt föreläggande utfärdades i mars 2026. Det är värt att följa.
- Håll dig till offentliga sidor. Scrapa inte innehåll bakom inloggning, persondata eller något som kräver autentisering.
- Respektera rate limits. Överbelasta inte Amazons servrar. En paus på 2–5 sekunder mellan förfrågningar är rimlig.
- Använd data ansvarsfullt. Skrapa för analys, inte för att återpublicera upphovsrättsskyddat material.
- Rådgör med jurist vid kommersiell användning i stor skala, särskilt om du är i EU (GDPR gäller personuppgifter).
För en djupare genomgång, se vår guide om juridiska implikationer av web scraping.
Avslutning
Nu har du en fungerande Python-scraper för Amazon med verifierade 2025-selectors, en flerskiktad strategi mot blockering som går långt bortom "lägg till en User-Agent", praktiska schemaläggningsalternativ för kontinuerlig övervakning och exportmetoder som för in din data i Google Sheets, databaser eller vilket verktyg ditt team än använder.
Kort sammanfattning:
- Python + curl_cffi + BeautifulSoup ger dig full kontroll och omkring 94 % träffsäkerhet när det kombineras med TLS-efterlikning
- Skydd mot blockering kräver flera lager: header-rotation, TLS-efterlikning, proxy-rotation, rate limiting och exponentiell backoff
- Schemaläggning gör ett engångsskript till en kontinuerlig övervakningspipeline (cron, GitHub Actions eller Thunderbits inbyggda schemaläggare)
- Export bortom CSV — Google Sheets, SQLite, Airtable, Notion — är där det verkliga affärsvärdet finns
- Thunderbit erbjuder ett alternativ med 2 klick för icke-utvecklare eller för dig som hellre lägger tiden på att analysera data än att felsöka selectors
Om du vill testa koden är allt i den här guiden redo att kopiera och köra. Och om du hellre hoppar över kodandet helt och hållet låter Thunderbits gratisnivå dig prova no-code-metoden på Amazon direkt.
För mer, se våra guider om hur man skrapar Amazon-produkter och recensioner, bästa Python-verktygen för web scraping och skrapa Amazon-priser. Du kan också se steg-för-steg-genomgångar på Thunderbit YouTube Channel.
Lycka till med scrapingen — och må dina selectors överleva till nästa Amazon-uppdatering.
Vanliga frågor
1. Varför blockeras min Python-scraper för Amazon efter bara några få förfrågningar?
Amazon använder ett sexlagers försvarssystem: IP-reputationsanalys, TLS-fingerprinting (JA3/JA4), identifiering av webbläsarmiljö, beteendebiometri, CAPTCHA-utmaningar och ML-driven avvikelsedetektion. Ett enkelt requests-skript med bara en User-Agent-header klarar bara ungefär 2 % framgång. Du behöver TLS-efterlikning (curl_cffi), full header-rotation, proxy-rotation och rate limiting med slumpmässig jitter för att hålla åtkomsten stabil.
2. Vilka Python-bibliotek är bäst för att skrapa Amazon-produkter 2025?
curl_cffi för HTTP-förfrågningar med TLS-efterlikning (den största enskilda förbättringen), BeautifulSoup4 med lxml för HTML-parsning, pandas för datastrukturering och export samt Selenium eller Playwright som fallback för innehåll som renderas med JavaScript. Python används av 69,6 % av scraping-utvecklare.
3. Är det lagligt att skrapa Amazon-produktdata?
Scraping av offentligt tillgänglig data är generellt lagligt i USA, vilket stöds av domar som hiQ v. LinkedIn och Meta v. Bright Data. Amazons användarvillkor förbjuder automatiserad åtkomst, men domstolar skiljer mellan brott mot användarvillkor (civilrättsligt) och straffrättsliga överträdelser. Undvik alltid innehåll bakom inloggning, respektera rate limits och rådgör med jurist vid kommersiell användning i stor skala.
4. Kan jag skrapa Amazon utan att skriva någon kod?
Ja. Verktyg som Thunderbit låter dig skrapa Amazon-produkter på 2 klick med en Chrome-extension. Dess AI-drivna fältdetektering strukturerar datan automatiskt, och du kan exportera till Excel, Google Sheets, Airtable eller Notion gratis. När Amazon ändrar sin HTML anpassar sig Thunderbits AI utan manuella uppdateringar.
5. Hur ofta ändrar Amazon sina HTML-selectors, och hur håller jag min scraper uppdaterad?
Ofta och utan förvarning. Scraping-communityn rapporterar att 10–15 % av crawlers behöver veckovisa fixar på grund av DOM-förändringar. För att ligga steget före bör du övervaka din scrapers träffsäkerhet, spara rå HTML för omparsning och regelbundet kontrollera selectors mot live-sidor. Alternativt anpassar AI-drivna verktyg som Thunderbit sig automatiskt och eliminerar det här underhållsbehovet.
Läs mer
