Lær hvordan du henter Amazon-produkter med Python

Hvis du har fulgt en Amazon-scrapingveiledning bare for å møte en vegg av CAPTCHA-er, 503-feil eller helt tomme resultater — velkommen i klubben. De fleste Python-guider for Amazon-scraping som sirkulerer på nettet, ble skrevet i 2022 eller 2023, og bruker selektorer og metoder som Amazon for lengst har lukket igjen.

Jeg har brukt år på å bygge datauttrekksverktøy hos Thunderbit, og én ting kan jeg si av erfaring: Amazon er en av de vanskeligste sidene å skrape på en pålitelig måte. Plattformen endrer HTML-strukturen hele tiden, bruker et sekslags anti-bot-forsvar og viser til og med ulike sideoppsett til ulike brukere gjennom A/B-testing. I denne guiden skal jeg vise deg en Python-basert Amazon-scraper som faktisk fungerer i 2025 — med verifiserte CSS-selektorer, en lagdelt strategi mot blokkering og tips for planlegging og eksport som de fleste guider hopper helt over. Og for deg som bare trenger dataene uten å styre med Python, skal jeg også vise hvordan kan gjøre samme jobb på omtrent to klikk.

Hva er Amazon-produkt-scraping?

Amazon-produkt-scraping betyr å hente offentlig tilgjengelige data programmessig — produktnavn, priser, vurderinger, antall anmeldelser, bilder, lagerstatus og mer — fra Amazon sine produkt- og søkeresultatsider. I stedet for å kopiere informasjon manuelt fra hundrevis av oppføringer, besøker en scraper hver side, leser HTML-en og trekker ut dataene du vil ha i et strukturert format som CSV, Excel eller en database.

Tenk på det som å ansette en utrettelig praktikant som kan besøke tusen produktsider på tiden det tar deg å drikke morgenkaffen. Bortsett fra at denne praktikanten aldri skriver feil og ikke trenger lunsjpause.

Hvorfor skrape Amazon-produkter med Python?

Amazon har rundt på tvers av 30+ kategorier, drevet av omtrent . Tredjepartsselgere står nå for 69 % av den totale GMV-en. Å følge bare en liten del av det katalogen manuelt er umulig. Her er hvorfor team skraper Amazon:

Selve omfanget av Amazons prising gjør automatisering helt nødvendig: Amazon endrer priser , og gjennomsnittsprisen på et produkt oppdateres omtrent hver 10. minutt. Til sammenligning endrer konkurrenter som Best Buy og Walmart priser bare rundt 50 000 ganger i måneden. Ingen menneskelig stab kan holde tritt.

Python gir deg full kontroll over hele scrape-prosessen — du bestemmer hva som skal hentes ut, hvordan feil skal håndteres og hvor dataene skal lagres. Men det betyr også at du selv må ta ansvar for vedlikehold, anti-blokkering og at Amazon stadig endrer HTML-en sin.

Hva du kan hente fra Amazon — og hva du ikke bør hente

Fra offentlig tilgjengelige produktsider kan du vanligvis hente ut:

• Produkttittel (navn, merke)
• Pris (nåværende pris, originalpris, tilbudspris)
• Vurdering (gjennomsnittlig stjernevurdering)
• Antall anmeldelser
• Produktbilder (URL til hovedbildet)
• Tilgjengelighet / lagerstatus
• ASIN (Amazon Standard Identification Number)
• Produktbeskrivelse og punktlister
• Selgerinformasjon
• Produktvarianter (størrelse, farge osv.)

Dette bør du unngå:

• Data bak innlogging: utvidede anmeldelsessider, personlige kontodata, ordrehistorikk
• Personopplysninger: kjøpernavn, adresser, betalingsinformasjon
• Opphavsrettsbeskyttet innhold for viderpublisering: produktbeskrivelser og bilder er greit til analyse, men ikke republiser dem som dine egne

Amazons blokkerer 50+ navngitte bot-er (inkludert GPTBot, Scrapy og ClaudeBot) og forbyr stier som brukerkontoer, handlekurver og ønskelister. Produktsidene er ikke eksplisitt forbudt, men Amazons vilkår for bruk sier likevel nei til automatisert tilgang. Domstoler har som regel skilt mellom brudd på vilkår for bruk (et sivilt spørsmål) og straffbare brudd under CFAA — mer om lovlighet mot slutten av guiden.

Verktøy og biblioteker du trenger

Her er Python-stakken for denne guiden:

Valgfritt (for innhold som rendres med JavaScript):

• selenium eller playwright — headless nettleserautomatisering

Slik setter du opp Python-miljøet

Åpne terminalen og kjø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

Sjekk at alt er installert:

1import requests, bs4, curl_cffi, pandas
2print("Alt er i orden!")

Ser du "Alt er i orden!" uten feil, er du klar.

Hvorfor de fleste Amazon-scrapingguider slutter å virke — og hva som er annerledes her

Dette er delen de fleste guider hopper over, og det er også grunnen til at du sannsynligvis leser denne artikkelen.

Amazon oppdaterer ofte HTML-strukturen, klassenavn og element-ID-er. Scraping-miljøet melder at på grunn av DOM-endringer og endringer i fingeravtrykk. Den mest kjente synderen? Selektoren #priceblock_ourprice, som dukket opp i hundrevis av guider fra 2018–2023. Den ID-en finnes ikke lenger på Amazons produktsider.

En rask sammenligning av hva som er ødelagt og hva som fungerer nå:

Alle kodeeksemplene i denne guiden er testet mot levende Amazon-sider i 2025. Jeg viser de faktiske CSS-selektorene sammen med forventet output — ikke copy-paste fra 2022.

Før du begynner

• Vanskelighetsgrad: Middels (grunnleggende Python-kunnskap antas)
• Tidsbruk: Ca. 30–45 minutter for hele guiden; ca. 10 minutter for en enkel scraper
• Dette trenger du: Python 3.9+, Chrome-nettleser (for å inspisere Amazon-sider), en terminal, og eventuelt hvis du vil sammenligne med en kodefri løsning

Steg 1: Send den første forespørselen til Amazon

Gå til en Amazon-produktside i nettleseren og kopier URL-en. Vi starter 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])

Kjører du dette, vil du nesten garantert få en 503-statuskode eller en side som sier "To discuss automated access to Amazon data please contact…". Det er Amazons WAF (Web Application Firewall) som oppdager Python-scriptet ditt. En ren requests.get() uten riktige headere gir bare rundt mot Amazon.

Du bør se noe sånt som 503 og en blokkeringsside i HTML-en. Det er forventet — vi fikser det i neste steg.

Steg 2: Sett opp egendefinerte headere og TLS-etterligning

Det holder ikke lenger å bare legge til en User-Agent-header. Amazon sammenligner HTTP-headerne dine med TLS-fingeravtrykket ditt. Hvis du påstår at du er Chrome 120, men TLS-handshaken avslører Python-biblioteket requests, blir du .

Den mest pålitelige metoden i 2025 er å bruke curl_cffi med nettleser-etterligning:

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 etterligner Chrome 124, hopper suksessraten til omtrent — en 47x forbedring sammenlignet med ren requests. Nå bør du se en 200-statuskode og et mye lengre HTML-svar (100 000+ tegn).

Hvis du fortsatt får 503, prøv en annen impersonate-verdi (for eksempel "chrome131") eller legg inn en kort pause før du prøver igjen.

Steg 3: Parse HTML-en og trekk ut produktdata

Nå som vi har full HTML, kan vi hente ut dataene med BeautifulSoup og verifiserte 2025-selektorer:

1from bs4 import BeautifulSoup
2soup = BeautifulSoup(response.text, "lxml")
3# Produkttittel
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# Vurdering
16rating_el = soup.select_one("#acrPopover span.a-icon-alt")
17rating = rating_el.get_text(strip=True) if rating_el else None
18# Antall anmeldelser
19reviews_el = soup.select_one("span#acrCustomerReviewText")
20reviews = reviews_el.get_text(strip=True) if reviews_el else None
21# Tilgjengelighet
22avail_el = soup.select_one("div#availability span")
23availability = avail_el.get_text(strip=True) if avail_el else None
24# Hovedbilde-URL
25img_el = soup.select_one("#landingImage")
26image_url = img_el.get("src") if img_el else None
27print(f"Tittel: {title}")
28print(f"Pris: {price}")
29print(f"Vurdering: {rating}")
30print(f"Anmeldelser: {reviews}")
31print(f"Tilgjengelighet: {availability}")
32print(f"Bilde: {image_url}")

Forventet output (eksempel):

1Tittel: Apple AirPods Pro (2nd Generation) with USB-C
2Pris: $189.99
3Vurdering: 4.7 out of 5 stars
4Anmeldelser: 98,432 ratings
5Tilgjengelighet: In Stock
6Bilde: https://m.media-amazon.com/images/I/61SUj2...

Legg merke til de flere fallback-selektorene for pris — Amazon bruker ulike containere avhengig av produkttype, tilbudsstatus og A/B-testvariant. Ved å pakke hver uthenting inn i en betingelse unngår du at scraperen krasjer når en selektor ikke matcher.

Steg 4: Skrap flere produkter fra søkeresultater

For å bygge et reelt datasett bør du starte fra en Amazon-søkeresultatside, samle ASIN-er og deretter skrape hver produktside.

1import time
2import random
3def get_search_asins(keyword, max_pages=1):
4    """Samler ASIN-er fra Amazons søkeresultater."""
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økeside {page} returnerte {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"Side {page}: fant {len(results)} produkter")
19        time.sleep(random.uniform(2, 5))  # Hensynsfull pause
20    return asins
21asins = get_search_asins("wireless+earbuds", max_pages=2)
22print(f"Samlet {len(asins)} ASIN-er")

Hver ASIN peker til en ren produkt-URL: https://www.amazon.com/dp/{ASIN}. Dette er mer pålitelig enn å bruke hele søkeresultat-URL-er, som kan inneholde sesjonsspesifikke parametere.

Steg 5: Håndter paginering og skrap i stor skala

La oss nå kombinere innsamling fra søk og scraping av produktsider til en full pipeline:

1import pandas as pd
2def scrape_product(asin):
3    """Skraper en enkelt Amazon-produktside."""
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"Feil ved scraping av {asin}: {e}")
32        return None
33# Skrap alle innsamlede ASIN-er
34products = []
35for i, asin in enumerate(asins):
36    print(f"Skraper {i+1}/{len(asins)}: {asin}")
37    product = scrape_product(asin)
38    if product:
39        products.append(product)
40    time.sleep(random.uniform(2, 5))  # Tilfeldig pause mellom forespørsler
41df = pd.DataFrame(products)
42print(f"\nSkrapet {len(df)} produkter успешно")
43print(df.head())

Den tilfeldige pausen på 2–5 sekunder er avgjørende. Perfekt regelmessig timing (for eksempel nøyaktig 3 sekunder hver gang) ser mistenkelig ut for Amazons atferdsanalyse. Tilfeldige intervaller etterligner menneskelig surfing.

Steg 6: Lagre Amazon-dataene til CSV

1df.to_csv("amazon_products.csv", index=False, encoding="utf-8-sig")
2print("Lagret til amazon_products.csv")

Nå bør du ha en ren CSV med kolonner for ASIN, tittel, pris, vurdering, anmeldelser, tilgjengelighet, bilde-URL og produkt-URL. Dette er der de fleste guider stopper — men hvis du bygger en reell arbeidsflyt, er CSV bare starten.

Dypdykk i anti-blokkering: Slik holder du scraperen i gang

Å bli blokkert er for alle som prøver å skrape Amazon-produkter med Python. Amazons sekslagsforsvar inkluderer IP-reputasjonsanalyse, TLS-fingerprinting, kontroll av nettlesermiljø, atferdsbiometri, CAPTCHA-er og ML-basert avviksdeteksjon. Under er en lagdelt strategi for å møte hver av dem.

Roter User-Agents og alle headere

En enkelt statisk User-Agent blir raskt avslørt. Roter mellom en liste med moderne nettleserstrenger:

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 ofte skaper trøbbel: Accept-Language må passe med den geografiske plasseringen IP-en din antyder. Å sende Accept-Language: en-US fra en tysk IP er et rødt flagg.

TLS-fingerprinting med curl_cffi

Vi dekket dette i steg 2, men det er verdt å understreke: denne ene teknikken gir størst løft i suksessrate. Vanlig Python requests gir rundt 2 % suksess mot Amazon. Med curl_cffi-etterligning er du nærmere 94 %. Det er forskjellen mellom en fungerende og en ødelagt scraper.

1from curl_cffi import requests as cfreq
2# Roter også hvilke nettlesere som etterlignes
3BROWSERS = ["chrome120", "chrome124", "chrome131"]
4response = cfreq.get(
5    url,
6    headers=get_headers(),
7    impersonate=random.choice(BROWSERS),
8)

Proxy-rotasjon

For scraping av mer enn noen få sider trenger du proxy-rotasjon. Amazon sporer IP-adresser og vil blokkere enhver IP som sender for mange forespørsler.

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 fungerer bedre enn datacenter-proxyer (Amazon blokkerer datacenter-IP-er proaktivt), men de er også dyrere. For et lite prosjekt kan du starte med en og skalere opp ved behov.

Hastighetsbegrensning og eksponentiell backoff

Ingen konkurrerende artikkel jeg fant dekker dette godt, men det er helt nødvendig. Når du får en 503 eller CAPTCHA, bør du ikke bare prøve igjen med en gang — det er en rask vei til permanent blokkering.

1import time
2import random
3def fetch_with_backoff(url, max_retries=3):
4    """Henter en URL med eksponentiell backoff ved feil."""
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        # Eksponentiell backoff med tilfeldig variasjon
14        wait = min(2 ** attempt + random.uniform(0, 1), 30)
15        print(f"Forsøk {attempt+1} feilet ({response.status_code}). Venter {wait:.1f}s...")
16        time.sleep(wait)
17    return None  # Alle forsøk brukt opp

Formelen wait = min(2^attempt + jitter, max_delay) sørger for at pausene øker (2s, 4s, 8s...) uten å bli urimelig lange. Den tilfeldige variasjonen hindrer at retry-mønsteret ditt blir fingeravtrykkbart.

Selenium- eller Playwright-fallback for innhold som rendres med JS

Noen Amazon-sider (særlig de med dynamiske pris-widgets eller variantvelgere) trenger JavaScript for å rendres helt. Når curl_cffi gir ufullstendig HTML, er en headless nettleser fallbacken:

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)  # La JS rendres
8        html = page.content()
9        browser.close()
10        return html

Dette er tregere — 3–5 sekunder per side mot under 1 sekund med curl_cffi. Bruk det bare når det er nødvendig.

Etter min erfaring håndterer curl_cffi mer enn 90 % av Amazon-produksidene uten nettleser.

Oppsummering av anti-blokkering

Mer enn CSV: Eksporter Amazon-data til Google Sheets, Airtable og mer

Alle guider jeg har sett stopper ved CSV-eksport. Men ekte arbeidsflyter i bedrifter trenger data i Google Sheets, databaser eller verktøy som Airtable og Notion.

Eksporter til Google Sheets med gspread

Først setter du opp en Google servicekonto (engangsoppsett):

1. Gå til → APIs & Services → Credentials
2. Opprett en servicekonto og last ned JSON-nøkkelfilen
3. Lagre den til ~/.config/gspread/service_account.json
4. Del målarket med client_email fra JSON-filen

Deretter:

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 eksportert til Google Sheets!")

Dette skriver hele DataFrame-en direkte til et Google Sheet — live, delbart og klart for dashboards.

Lagre i SQLite for lokal analyse

For større datasett eller historisk sporing er SQLite perfekt — ingen serveroppsett, bare én fil:

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

Det kodefrie alternativet

Hvis du ikke vil vedlikeholde eksportskript i Python, tilbyr gratis eksport til Google Sheets, Airtable, Notion, Excel, CSV og JSON — inkludert bildefelter som vises direkte i Airtable og Notion. Ingen gspread-oppsett, ingen API-nøkler, ingen kode i det hele tatt. For team som vil få data inn i eksisterende verktøy, er dette en stor tidsbesparelse.

Planlegging av automatiske Amazon-scrapes — kapittelet som mangler

Prisovervåking og lageroppfølging krever gjentatte scrapes, ikke engangskjøringer. Likevel fant jeg ikke én eneste konkurrentartikkel som dekker planlegging. Slik automatiserer du Python-scraperen din.

Cron-jobber (Linux/macOS)

Åpne crontab-en din:

1crontab -e

Legg til en linje som kjører scraperen daglig kl. 06:00:

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

Eller hver 6. time:

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

Windows Task Scheduler

Lag en batch-fil run_scraper.bat:

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

Åpne deretter Task Scheduler → Create Basic Task → velg trigger (Daily, Hourly) → Action: "Start a program" → pek til run_scraper.bat.

GitHub Actions (gratisnivå)

For en skyløsning uten egen infrastruktur:

1name: Amazon Scraper
2on:
3  schedule:
4    - cron: "0 6 * * *"  # Daglig kl. 06:00 UTC
5  workflow_dispatch:       # Manuell kjøring
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 "Oppdaterte data fra scraping"
25          git push

Lagre proxy-legitimasjon i GitHub Secrets, så har du en gratis, automatisert scraping-pipeline.

Kodefritt alternativ: Thunderbits Scheduled Scraper

For team som ikke vil styre med cron-syntaks eller skyinfrastruktur, tilbyr Thunderbit en innebygd . Du beskriver planen med vanlig språk (for eksempel "hver dag kl. 08" eller "hver mandag"), legger inn Amazon-URL-ene dine og klikker "Schedule." Ingen terminal, ingen YAML-filer, ingen deploy-pipeline. Dette er spesielt nyttig for ecommerce-team som kjører kontinuerlig pris- eller lagerovervåking.

Python DIY vs. Scraper API vs. kodefritt: Hvilken tilnærming bør du velge?

Dette er et spørsmål jeg ser hele tiden i forum, og ingen topprangert artikkel gir et strukturert svar. Så her er min ærlige vurdering:

Python er riktig valg hvis du vil lære, tilpasse alt og ikke har noe imot vedvarende vedlikehold. Scraper API-er håndterer anti-blokkering for deg, men krever fortsatt kode. Thunderbit er den raskeste veien for salg, ecommerce-drift eller alle som bare trenger dataene — uten selektorer, uten kode og uten vedlikehold når Amazon endrer HTML-en.

Slik skraper Thunderbit Amazon-produkter på 2 klikk

Jeg er selvsagt litt partisk — teamet mitt bygde dette. Men arbeidsflyten er faktisk så enkel:

1. Installer
2. Gå til en Amazon-søkeresultat- eller produktside
3. Klikk "AI Suggest Fields" (eller bruk den ferdige Amazon-scraper-malen)
4. Klikk "Scrape"

Thunderbits AI leser siden, forstår datastrukturen og trekker ut alt i en ryddig tabell. Du kan eksportere til Excel, Google Sheets, Airtable eller Notion gratis. Den virkelige gevinsten: når Amazon endrer HTML-en neste uke (og det gjør de), tilpasser Thunderbits AI seg automatisk. Ingen ødelagte skript, ingen oppdatering av selektorer.

For å berike produktlister med data fra produktsider bruker Thunderbits funksjon Subpage Scraping automatisk lenkene videre til produktsidene og henter ekstra felt som bilder, beskrivelser og varianter — noe som krever mye ekstra kode i Python.

Tips for å holde Python-baserte Amazon-scrapere stabile over tid

Hvis du velger Python-sporet, er dette hvordan du reduserer vedlikeholdsfriksjon:

• Sjekk selektorer jevnlig. Amazon endrer dem ofte. Bokmerk denne artikkelen — jeg oppdaterer selektortabellen når ting endrer seg.
• Overvåk suksessraten. Følg med på forholdet mellom 200-svar og 503-er/CAPTCHA-er. Sett opp et varsel (selv en enkel e-post) når suksessraten faller under 80 %.
• Lagre rå HTML. Ta vare på hele HTML-svaret sammen med de parsede dataene. Hvis selektorer endres, kan du parse historiske data på nytt uten å scrape på nytt.
• Roter proxyer og User-Agents ofte. Statiske fingeravtrykk blir avslørt i løpet av timer i stor skala.
• Bruk eksponentiell backoff. Prøv aldri igjen umiddelbart etter en blokkering.
• Containeriser med Docker. Pakk scraperen inn i en Docker-container for enkel utrulling og portabilitet.
• Legg inn datavalidering. Sjekk at priser er numeriske, vurderinger ligger mellom 1–5, og at titler ikke er tomme. Ett team rapporterte etter å ha lagt til valideringslag.

Eller, hvis alt dette høres ut som mer jobb enn du egentlig ville ha, bør du vurdere om et kodefritt verktøy som Thunderbit passer bedre. Det er ingen skam i å velge den raskeste veien — jeg har brukt nok år på å feilsøke scrapers til å vite at den beste koden noen ganger er koden du slipper å skrive.

Juridiske og etiske vurderinger ved scraping av Amazon

Siden dette alltid dukker opp i samtaler om Amazon-scraping, en kort oversikt over det juridiske landskapet:

• Scraping av offentlig tilgjengelige data er som regel lovlig i USA. Den viktige avgjørelsen (2022) slo fast at tilgang til offentlig data ikke bryter CFAA. Mer nylig styrket (2024) og (2024) dette prinsippet.
• Amazons vilkår for bruk forbyr automatisert tilgang. Dette er et sivilt spørsmål (kontraktsbrudd), ikke et straffbart ett. Domstoler har vanligvis skilt mellom disse.
• Amazon v. Perplexity (2025) er en pågående sak som involverer AI-scraping av Amazon-sider. Det ble utstedt et foreløpig forbud i mars 2026. Dette er verdt å følge med på.
• Hold deg til offentlige sider. Ikke skrap innhold bak innlogging, persondata eller noe som krever autentisering.
• Respekter hastighetsgrenser. Ikke overbelast Amazons servere. En pause på 2–5 sekunder mellom forespørsler er rimelig.
• Bruk dataene ansvarlig. Skrap til analyse, ikke for å republisere opphavsrettsbeskyttet innhold.
• Snakk med juridisk rådgiver ved stor kommersiell bruk, spesielt hvis du er i EU (GDPR gjelder for persondata).

For en dypere gjennomgang, se guiden vår om .

Oppsummering

Nå har du en fungerende Python Amazon-scraper med verifiserte 2025-selektorer, en lagdelt strategi mot blokkering som går langt forbi «bare legg til en User-Agent», praktiske planleggingsmuligheter for kontinuerlig overvåking og eksportmetoder som får dataene dine inn i Google Sheets, databaser eller andre verktøy teamet bruker.

Kort oppsummert:

• Python + curl_cffi + BeautifulSoup gir deg full kontroll og rundt 94 % suksessrate når det kombineres med TLS-etterligning
• Anti-blokkering krever flere lag: header-rotasjon, TLS-etterligning, proxy-rotasjon, hastighetsbegrensning og eksponentiell backoff
• Planlegging gjør et engangsskript om til en kontinuerlig overvåkingspipeline (cron, GitHub Actions eller Thunderbits innebygde scheduler)
• Eksport utover CSV — Google Sheets, SQLite, Airtable, Notion — er der den virkelige forretningsverdien ligger
• Thunderbit tilbyr et 2-klikk-alternativ for ikke-utviklere eller alle som heller vil bruke tiden på å analysere data enn å feilsøke selektorer

Hvis du vil prøve koden, er alt i denne guiden klart til å kopieres og kjøres. Og hvis du heller vil hoppe over koding helt, lar deg teste den kodefrie tilnærmingen på Amazon med en gang.

For mer, se guidene våre om , og . Du kan også se trinnvise gjennomganger på .

God scraping — og må selektorene dine overleve til neste Amazon-oppdatering.

FAQ

1. Hvorfor blir Python-Amazon-scraperen min blokkert etter noen få forespørsler?

Amazon bruker et sekslags forsvarssystem: IP-reputasjonsanalyse, TLS-fingerprinting (JA3/JA4), deteksjon av nettlesermiljø, atferdsbiometri, CAPTCHA-utfordringer og ML-basert avviksdeteksjon. Et enkelt requests-skript med bare en User-Agent-header oppnår bare rundt suksess. Du trenger TLS-etterligning (curl_cffi), full header-rotasjon, proxy-rotasjon og hastighetsbegrensning med tilfeldig jitter for å få stabil tilgang.

2. Hvilke Python-biblioteker er best for å skrape Amazon-produkter i 2025?

curl_cffi for TLS-etterlignede HTTP-forespørsler (den største enkeltforbedringen), BeautifulSoup4 med lxml for HTML-parsing, pandas for strukturering og eksport av data, og Selenium eller Playwright som fallback for JavaScript-rendret innhold. Python brukes av av utviklere som jobber med scraping.

3. Er det lov å skrape Amazon-produktdata?

Å skrape offentlig tilgjengelige data er som regel lovlig i USA, støttet av avgjørelser som hiQ v. LinkedIn og Meta v. Bright Data. Amazons vilkår for bruk forbyr automatisert tilgang, men domstoler skiller mellom brudd på vilkår (sivilt) og straffbare brudd. Unngå alltid innhold bak innlogging, respekter hastighetsgrenser, og rådfør deg med juridisk ekspertise ved stor kommersiell bruk.

4. Kan jeg skrape Amazon uten å skrive kode?

Ja. Verktøy som lar deg skrape Amazon-produkter med 2 klikk via en Chrome-utvidelse. Den AI-drevne feltdeteksjonen strukturerer dataene automatisk, og du kan eksportere til Excel, Google Sheets, Airtable eller Notion gratis. Når Amazon endrer HTML, tilpasser Thunderbits AI seg uten manuelle oppdateringer.

5. Hvor ofte endrer Amazon HTML-selektorene sine, og hvordan holder jeg scraperen oppdatert?

Ofte og uten varsel. Scraping-miljøet rapporterer at av crawlerne trenger ukentlige fiks på grunn av DOM-endringer. For å ligge i forkant bør du overvåke suksessraten til scraperen, lagre rå HTML for ny parsing og sjekke selektorer mot levende sider jevnlig. Alternativt tilpasser AI-drevne verktøy som Thunderbit seg automatisk og fjerner dette vedlikeholdsbehovet.

Lær mer