Lär dig att skrapa Amazon-produkter med Python

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 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 inom fler än 30 kategorier, drivna av omkring . 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:

Amazons prissättning i sig gör automatisering nödvändig: Amazon ändrar priser , 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 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:

Valfritt (för innehåll som renderas med JavaScript):

• selenium eller playwright — headless webbläsarautomatisering

Så här sätter du upp din Python-miljö

Öppna terminalen och kör:

1mkdir amazon-scraper && cd amazon-scraper
2python -m venv venv
3source venv/bin/activate  # På Windows: venv\Scripts\activate
4pip install requests beautifulsoup4 lxml curl_cffi pandas

Kontrollera att allt installerats:

1import requests, bs4, curl_cffi, pandas
2print("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 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:

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 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():

1import requests
2url = "https://www.amazon.com/dp/B0DGNFM9YJ"
3response = requests.get(url)
4print(response.status_code)
5print(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 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 .

Det mest pålitliga tillvägagångssättet 2025 är att använda curl_cffi med webbläsar-efterlikning:

1from curl_cffi import requests as cfreq
2headers = {
3    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
4    "Accept-Language": "en-US,en;q=0.9",
5    "Accept-Encoding": "gzip, deflate, br",
6    "Referer": "https://www.google.com/",
7    "DNT": "1",
8    "Connection": "keep-alive",
9    "Upgrade-Insecure-Requests": "1",
10}
11url = "https://www.amazon.com/dp/B0DGNFM9YJ"
12response = cfreq.get(url, headers=headers, impersonate="chrome124")
13print(response.status_code)
14print(len(response.text))

Med curl_cffi som efterliknar Chrome 124 ökar träffsäkerheten till cirka — 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:

1from bs4 import BeautifulSoup
2soup = BeautifulSoup(response.text, "lxml")
3# Produkttitel
4title_el = soup.select_one("span#productTitle")
5title = title_el.get_text(strip=True) if title_el else None
6# Pris
7price_el = soup.select_one(
8    "div#corePriceDisplay_desktop_feature_div span.a-price .a-offscreen"
9)
10if not price_el:
11    price_el = soup.select_one("span.priceToPay .a-offscreen")
12if not price_el:
13    price_el = soup.select_one(".apexPriceToPay .a-offscreen")
14price = price_el.get_text(strip=True) if price_el else None
15# Betyg
16rating_el = soup.select_one("#acrPopover span.a-icon-alt")
17rating = rating_el.get_text(strip=True) if rating_el else None
18# Antal recensioner
19reviews_el = soup.select_one("span#acrCustomerReviewText")
20reviews = reviews_el.get_text(strip=True) if reviews_el else None
21# Tillgänglighet
22avail_el = soup.select_one("div#availability span")
23availability = avail_el.get_text(strip=True) if avail_el else None
24# Huvudbildens URL
25img_el = soup.select_one("#landingImage")
26image_url = img_el.get("src") if img_el else None
27print(f"Title: {title}")
28print(f"Price: {price}")
29print(f"Rating: {rating}")
30print(f"Reviews: {reviews}")
31print(f"Availability: {availability}")
32print(f"Image: {image_url}")

Förväntad output (exempel):

1Title: Apple AirPods Pro (2nd Generation) with USB-C
2Price: $189.99
3Rating: 4.7 out of 5 stars
4Reviews: 98,432 ratings
5Availability: In Stock
6Image: 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.

1import time
2import random
3def get_search_asins(keyword, max_pages=1):
4    """Samla ASIN:er från Amazons sökresultat."""
5    asins = []
6    for page in range(1, max_pages + 1):
7        search_url = f"https://www.amazon.com/s?k={keyword}&page={page}"
8        resp = cfreq.get(search_url, headers=headers, impersonate="chrome124")
9        if resp.status_code != 200:
10            print(f"Sökresultatssida {page} returnerade {resp.status_code}")
11            break
12        search_soup = BeautifulSoup(resp.text, "lxml")
13        results = search_soup.select('div[data-component-type="s-search-result"]')
14        for r in results:
15            asin = r.get("data-asin")
16            if asin:
17                asins.append(asin)
18        print(f"Sida {page}: hittade {len(results)} produkter")
19        time.sleep(random.uniform(2, 5))  # Hänsynsfull fördröjning
20    return asins
21asins = get_search_asins("wireless+earbuds", max_pages=2)
22print(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:

1import pandas as pd
2def scrape_product(asin):
3    """Skrapa en enskild Amazons detaljsida för en produkt."""
4    url = f"https://www.amazon.com/dp/{asin}"
5    try:
6        resp = cfreq.get(url, headers=headers, impersonate="chrome124")
7        if resp.status_code != 200:
8            return None
9        soup = BeautifulSoup(resp.text, "lxml")
10        title_el = soup.select_one("span#productTitle")
11        price_el = (
12            soup.select_one("div#corePriceDisplay_desktop_feature_div span.a-price .a-offscreen")
13            or soup.select_one("span.priceToPay .a-offscreen")
14            or soup.select_one(".apexPriceToPay .a-offscreen")
15        )
16        rating_el = soup.select_one("#acrPopover span.a-icon-alt")
17        reviews_el = soup.select_one("span#acrCustomerReviewText")
18        avail_el = soup.select_one("div#availability span")
19        img_el = soup.select_one("#landingImage")
20        return {
21            "asin": asin,
22            "title": title_el.get_text(strip=True) if title_el else None,
23            "price": price_el.get_text(strip=True) if price_el else None,
24            "rating": rating_el.get_text(strip=True) if rating_el else None,
25            "reviews": reviews_el.get_text(strip=True) if reviews_el else None,
26            "availability": avail_el.get_text(strip=True) if avail_el else None,
27            "image_url": img_el.get("src") if img_el else None,
28            "url": url,
29        }
30    except Exception as e:
31        print(f"Fel vid scraping av {asin}: {e}")
32        return None
33# Skrapa alla insamlade ASIN:er
34products = []
35for i, asin in enumerate(asins):
36    print(f"Skrapar {i+1}/{len(asins)}: {asin}")
37    product = scrape_product(asin)
38    if product:
39        products.append(product)
40    time.sleep(random.uniform(2, 5))  # Slumpmässig paus mellan förfrågningar
41df = pd.DataFrame(products)
42print(f"\nSkrapade {len(df)} produkter utan fel")
43print(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

1df.to_csv("amazon_products.csv", index=False, encoding="utf-8-sig")
2print("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 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:

1import random
2USER_AGENTS = [
3    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.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/143.0.0.0 Safari/537.36",
5    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0",
6    "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",
7]
8def get_headers():
9    return {
10        "User-Agent": random.choice(USER_AGENTS),
11        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
12        "Accept-Language": "en-US,en;q=0.9",
13        "Accept-Encoding": "gzip, deflate, br",
14        "Referer": "https://www.google.com/",
15        "DNT": "1",
16        "Connection": "keep-alive",
17    }

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.

1from curl_cffi import requests as cfreq
2# Rotera även mellan olika impersonation-mål
3BROWSERS = ["chrome120", "chrome124", "chrome131"]
4response = cfreq.get(
5    url,
6    headers=get_headers(),
7    impersonate=random.choice(BROWSERS),
8)

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.

1PROXIES = [
2    "http://user:pass@proxy1.example.com:8080",
3    "http://user:pass@proxy2.example.com:8080",
4    "http://user:pass@proxy3.example.com:8080",
5]
6proxy = random.choice(PROXIES)
7response = cfreq.get(
8    url,
9    headers=get_headers(),
10    impersonate="chrome124",
11    proxies={"http": proxy, "https": proxy},
12)

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

1import time
2import random
3def fetch_with_backoff(url, max_retries=3):
4    """Hämta en URL med exponentiell backoff vid fel."""
5    for attempt in range(max_retries):
6        response = cfreq.get(
7            url,
8            headers=get_headers(),
9            impersonate=random.choice(BROWSERS),
10        )
11        if response.status_code == 200:
12            return response
13        # Exponentiell backoff med slumpmoment
14        wait = min(2 ** attempt + random.uniform(0, 1), 30)
15        print(f"Försök {attempt+1} misslyckades ({response.status_code}). Väntar {wait:.1f}s...")
16        time.sleep(wait)
17    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:

1from playwright.sync_api import sync_playwright
2def scrape_with_browser(url):
3    with sync_playwright() as p:
4        browser = p.chromium.launch(headless=True)
5        page = browser.new_page()
6        page.goto(url, wait_until="domcontentloaded")
7        page.wait_for_timeout(3000)  # Låt JS rendera
8        html = page.content()
9        browser.close()
10        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

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):

1. Gå till → APIs & Services → Credentials
2. Skapa ett servicekonto och ladda ned JSON-nyckelfilen
3. Spara den till ~/.config/gspread/service_account.json
4. Dela ditt kalkylark med client_email från JSON-filen

Sedan:

1import gspread
2from gspread_dataframe import set_with_dataframe
3gc = gspread.service_account()
4sh = gc.open("Amazon Scrape Data")
5worksheet = sh.sheet1
6set_with_dataframe(worksheet, df)
7print("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:

1import sqlite3
2conn = sqlite3.connect("amazon_products.db")
3df.to_sql("products", conn, if_exists="append", index=False)
4print(f"Lagrade {len(df)} produkter i SQLite")
5# Fråga senare:
6historical = pd.read_sql_query(
7    "SELECT * FROM products WHERE price IS NOT NULL ORDER BY rowid DESC LIMIT 100",
8    conn,
9)

No-code-alternativet

Om du inte vill underhålla Python-skript för export erbjuder 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:

1crontab -e

Lägg till en rad som kör din scraper varje dag klockan 06:00:

10 6 * * * cd /path/to/amazon-scraper && /path/to/venv/bin/python scraper.py >> ~/scraper.log 2>&1

Eller var sjätte timme:

10 */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:

1@echo off
2cd /d "C:\path\to\amazon-scraper"
3call venv\Scripts\activate
4python scraper.py
5deactivate

Ö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:

1name: Amazon Scraper
2on:
3  schedule:
4    - cron: "0 6 * * *"  # Dagligen kl. 06:00 UTC
5  workflow_dispatch:       # Manuell start
6jobs:
7  scrape:
8    runs-on: ubuntu-latest
9    steps:
10      - uses: actions/checkout@v3
11      - name: Set up Python
12        uses: actions/setup-python@v4
13        with:
14          python-version: "3.11"
15      - name: Install dependencies
16        run: pip install -r requirements.txt
17      - name: Run scraper
18        run: python scraper.py
19      - name: Commit results
20        run: |
21          git config user.name 'GitHub Actions'
22          git config user.email 'actions@github.com'
23          git add data/
24          git diff --staged --quiet || git commit -m "Uppdatera skrapad data"
25          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 . 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:

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:

1. Installera
2. Gå till en Amazon-sökresultatsida eller produktsida
3. Klicka på "AI Suggest Fields" (eller använd den direkt färdiga Amazon-scraper-mallen)
4. 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 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 (2022) slog fast att åtkomst till offentlig data inte bryter mot CFAA. Senare förstärkte (2024) och (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 .

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 dig prova no-code-metoden på Amazon direkt.

För mer, se våra guider om , och . Du kan också se steg-för-steg-genomgångar på .

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