Automatisér din markedsanalyse: Sådan scraper du Shopify med Python

Shopifys /products.json-endpoint er en af e-handelsverdenens dårligst bevarede hemmeligheder. Tilføj det til enhver Shopify-butik-URL, og du får struktureret JSON tilbage — uden API-nøgler, uden autentificering og uden at skulle rode dig gennem indlejret HTML.

Jeg arbejder på -teamet, så jeg bruger en hel del tid på at tænke over, hvordan folk udtrækker data fra nettet. Og Shopify-scraping dukker op hele tiden — salgsteams, der holder øje med konkurrenternes priser, ecommerce-ansvarlige, der benchmarker produktkataloger, og indkøbere, der finder nye leverandører. Med på Shopify og en platform, der står for omkring , er mængden af produktdata, du kan udtrække, enorm.

Denne guide gennemgår hele processen: hvad endpointet returnerer, hvordan du paginerer gennem tusindvis af produkter, hvordan du undgår at blive ramt af rate limits, og hvordan du flader Shopifys indlejrede JSON ud til en ren CSV- eller Excel-fil med pandas. Jeg gennemgår også de endpoints, næsten ingen andre taler om (/collections.json, /meta.json), og viser et no-code-alternativ til dem, der helst vil springe Python helt over.

Hvad er Shopifys /products.json-endpoint egentlig? Og hvorfor er det så nemt at scrape?

Hver Shopify-butik har et offentligt endpoint på {store-url}/products.json, som returnerer strukturerede produktdata. Ingen API-nøgler. Ingen OAuth. Ingen autentificering overhovedet. Du tilføjer bogstaveligt talt bare /products.json til butikkens URL og får en JSON-liste med alle produkter i kataloget.

Prøv selv lige nu: åbn eller i din browser. Du vil se ren, struktureret JSON med produkttitler, priser, varianter, billeder, tags — alt.

Sammenlign det med alternativet: at parse Shopifys HTML-temaer, som er dybt indlejrede, forskellige fra butik til butik og ændrer sig, hver gang en forhandler opdaterer sit tema. Her er, hvad du ellers skulle arbejde med:

HTML-tilgangen (bøvlet):

1<div class="product-card__info">
2  <h3 class="product-card__title">
3    <a href="/products/classic-blue-jeans">Classic Blue Jeans</a>
4  </h3>
5  <span class="price price--on-sale" data-product-price>$149.00</span>
6</div>

JSON-tilgangen (ren):

1{
2  "title": "Classic Blue Jeans",
3  "handle": "classic-blue-jeans",
4  "vendor": "Hiut Denim",
5  "variants": [{"price": "149.00", "sku": "HD-BLU-32", "available": true}]
6}

JSON vinder på konsistens, driftssikkerhed og nem parsing. Endpointet understøtter også to vigtige query-parametre — ?limit= (op til 250 produkter pr. side, standard er 30) og ?page= til pagination — som vi bruger flittigt i koden nedenfor.

Vigtig skelnen: Det her er et offentligt storefront-endpoint, ikke . Admin API kræver adgangstokens fra butiksejeren og giver adgang til ordredata, lagerstatus og kundeinformation. Det offentlige /products.json-endpoint er kun til læsning og kan tilgås af alle. Jeg gennemgår forskellen mere detaljeret senere, fordi der er masser af forvirring om det i fora.

En forbehold: Ikke alle Shopify-butikker eksponerer dette endpoint. I mine tests returnerede omkring 71 % af butikkerne gyldig JSON (allbirds.com, gymshark.com, colourpop.com, kyliecosmetics.com virker alle), mens nogle custom-opsætninger gav 404 (hiutdenim.co.uk, bombas.com). Den hurtige test er enkel: besøg {store-url}/products.json i din browser og se, hvad du får.

Hvorfor scrape Shopify med Python? De vigtigste forretningscases

Hvorfor overhovedet gøre det? ROI. bruger nu automatiseret prisscraping til konkurrentindsigt, mod kun 34 % i 2020. Og undersøgelser viser, at en . Data er med andre ord penge værd.

Her er de mest almindelige use cases, jeg ser:

This paragraph contains content that cannot be parsed and has been skipped.

Python er det oplagte valg til den slags arbejde. bruger Python som primært sprog, og økosystemet — requests til HTTP, pandas til datahåndtering, httpx til async — gør det nemt at gå fra “jeg har en URL” til “jeg har et regneark” på under 80 linjer kode.

Komplet reference til products.json-felter: Forklaring af alle felter

Alle andre guides viser dig title, id og handle og går så videre. Shopifys JSON-svar indeholder over 40 felter på tværs af produkter, varianter, billeder og optioner. Ved at kende, hvad der er tilgængeligt, før du skriver din scraping-kode, undgår du at skulle scrape igen senere.

Jeg har samlet denne reference fra live /products.json-svar hentet den 16. april 2026. Strukturen er den samme på tværs af alle butikker, der eksponerer endpointet.

Felter på produktniveau

Felter på variantniveau (indlejret under hvert produkt)

Felter på billedniveau

Hvad der IKKE findes i det offentlige endpoint

En vigtig faldgrube: inventory_quantity er IKKE tilgængelig i offentlige /products.json-svar. Dette felt blev fjernet fra offentlige JSON-endpoints i december 2017 af sikkerhedshensyn. Den eneste lagerindikator, du får, er den boolske available-værdi på hver variant (true eller false). For at få den faktiske lagerbeholdning skal du bruge det autentificerede Admin API med butiksejerens legitimationsoplysninger.

Før du skriver din scraping-kode, så gennemgå denne tabel og beslut, hvilke felter der er vigtige for dit use case. Hvis du laver prissporing, har du brug for variants[].price, variants[].compare_at_price og variants[].available. Hvis du laver leadgen, så fokuser på vendor, product_type og tags. Filtrér derefter — din CSV bliver meget renere.

Ud over products.json: Collections, meta og andre Shopify-endpoints

Ingen andre guides nævner disse endpoints. De er afgørende for seriøst arbejde med konkurrentindsigt.

/collections.json — alle butikkens kategorier

Returnerer alle kollektioner (kategorier) i butikken med titler, handles, beskrivelser og produktantal. Jeg verificerede dette på zoologistperfumes.com, allbirds.com og gymshark.com — alle returnerede gyldig JSON.

1{
2  "collections": [
3    {
4      "id": 308387348539,
5      "title": "Attars",
6      "handle": "attars",
7      "published_at": "2026-03-29T12:20:32-04:00",
8      "products_count": 1,
9      "image": { "src": "https://cdn.shopify.com/..." }
10    }
11  ]
12}

Vil du forstå, hvordan en konkurrent organiserer sit katalog? Så er det her endpointet.

/collections/{handle}/products.json — produkter efter kategori

Returnerer produkter filtreret efter en bestemt kollektion. Samme JSON-struktur som /products.json, men begrænset til én kategori. Det er særligt vigtigt til kategori-scraping — fx hvis du kun vil overvåge en konkurrents “Sale”- eller “New Arrivals”-kollektion.

/meta.json — metadata på butiksniveau

Returnerer butiksnavn, beskrivelse, valuta, land og — her er det gode — published_products_count. Det tal gør det muligt at beregne præcis, hvor mange paginering-sider du skal bruge: ceil(published_products_count / 250). Slut med at øge sidenummeret blindt, indtil du rammer et tomt svar.

Hvilket endpoint skal du bruge?

Det tilbagevendende forumspørgsmål — “Kan jeg scrape, hvor mange enheder en konkurrent har solgt?” — har et kort svar: nej. Ikke fra offentlige endpoints. Salgsdata og lagerantal kræver det autentificerede Admin API, hvilket betyder, at du skal have butiksejer-adgang. Offentlige endpoints giver dig kun produktkatalogdata.

Sådan scraper du Shopify med Python: Trin-for-trin opsætning

• Sværhedsgrad: Begynder
• Tidsforbrug: Ca. 15 minutter (opsætning + første scrape)
• Det skal du bruge: Python 3.11+, pip, en terminal og en Shopify-butik-URL at scrape

Trin 1: Installer Python og de nødvendige biblioteker

Sørg for, at du har Python 3.11 eller nyere installeret (pandas 3.0.x kræver det). Installer derefter de to biblioteker, vi skal bruge:

1pip install requests pandas

Hvis du også vil eksportere til Excel, skal du bruge:

1pip install openpyxl

Øverst i dit script tilføjer du disse imports:

1import requests
2import pandas as pd
3import time
4import random
5import json

Du bør ikke få nogen importfejl, når du kører scriptet. Hvis pandas giver en versionsfejl, så opgrader Python til 3.12.

Trin 2: Hent produktdata fra /products.json

Her er en grundlæggende funktion, der tager en butik-URL, rammer endpointet og returnerer parsed JSON:

1def fetch_products_page(store_url, page=1, limit=250):
2    """Hent en enkelt side med produkter fra en Shopify-butik."""
3    url = f"{store_url.rstrip('/')}/products.json"
4    params = {"limit": limit, "page": page}
5    headers = {
6        "User-Agent": "Mozilla/5.0 (compatible; ProductResearch/1.0)"
7    }
8    response = requests.get(url, params=params, headers=headers, timeout=30)
9    response.raise_for_status()
10    return response.json().get("products", [])

Vigtige detaljer:

• limit=250 er det maksimale, Shopify tillader pr. side. Standard er 30, så ved at sætte det eksplicit reducerer du antallet af kald med op til 8x.
• User-Agent-header: Sæt altid en realistisk brugeragent. Requests uden User-Agent har større sandsynlighed for at trigge Shopifys anti-bot-systemer.
• timeout=30: Lad ikke et enkelt kald hænge for evigt.

Test det med en kendt butik:

1products = fetch_products_page("https://allbirds.com")
2print(f"Hentede {len(products)} produkter")
3print(f"Første produkt: {products[0]['title']}")

Du bør se noget i stil med: Hentede 250 produkter og den første produkttitel.

Trin 3: Håndter pagination og hent alle produkter

Ét kald returnerer højst 250 produkter. De fleste butikker har mere end det (Allbirds har 1.420+). Du skal loope gennem siderne, indtil du får et tomt svar.

1def scrape_all_products(store_url, delay=1.0):
2    """Scrape alle produkter fra en Shopify-butik med pagination."""
3    all_products = []
4    page = 1
5    while True:
6        print(f"Henter side {page}...")
7        products = fetch_products_page(store_url, page=page, limit=250)
8        if not products:
9            print(f"Ingen flere produkter. I alt: {len(all_products)}")
10            break
11        all_products.extend(products)
12        print(f"  Fik {len(products)} produkter (i alt indtil nu: {len(all_products)})")
13        page += 1
14        # Vær høflig: vent mellem kald
15        time.sleep(delay + random.uniform(0, 0.5))
16    return all_products

Når products kommer tilbage tomt, er du ved vejs ende.

time.sleep() med en smule tilfældig variation hjælper dig med at holde dig under Shopifys uofficielle rate limit (~2 kald/sekund).

Pro tip: Hvis du har hentet /meta.json først, kender du allerede det samlede produktantal og kan beregne præcis, hvor mange sider du skal bruge: pages = ceil(product_count / 250). Så undgår du den ekstra tomme forespørgsel til sidst.

Trin 4: Udtræk og vælg de felter, du har brug for

Når du har alle produkter som en Python-liste af ordbøger, kan du udtrække de felter, du faktisk skal bruge. Her er et eksempel, der trækker de mest almindelige felter til prissporing:

1def extract_product_data(products):
2    """Udtræk nøglefelter fra produkter og fladgør varianter."""
3    rows = []
4    for product in products:
5        for variant in product.get("variants", []):
6            rows.append({
7                "product_id": product["id"],
8                "title": product["title"],
9                "handle": product["handle"],
10                "vendor": product.get("vendor", ""),
11                "product_type": product.get("product_type", ""),
12                "tags": ", ".join(product.get("tags", [])),
13                "created_at": product.get("created_at", ""),
14                "variant_id": variant["id"],
15                "variant_title": variant.get("title", ""),
16                "sku": variant.get("sku", ""),
17                "price": variant.get("price", ""),
18                "compare_at_price": variant.get("compare_at_price", ""),
19                "available": variant.get("available", ""),
20                "image_url": product["images"][0]["src"] if product.get("images") else ""
21            })
22    return rows

Det her giver én række pr. variant — den mest nyttige struktur til prissammenligning, fordi et enkelt produkt som “Classic Blue Jeans” kan have 12 varianter (6 størrelser × 2 farver), hver med sin egen pris og tilgængelighed.

Eksportér scraped Shopify-data til CSV og Excel med pandas

Alle andre Shopify-scraping-guides dumper bare rå JSON til en fil og kalder det en dag. Fint for udviklere. Ubrugeligt for ecommerce-analytikeren, der skal have et regneark inden fredag.

Problemet: Shopifys JSON er indlejret. Ét produkt kan indeholde et dusin varianter, hver med sin egen pris, SKU og tilgængelighed. At flade det ud til rækker og kolonner kræver lidt pandas-arbejde.

Flad nested JSON til en ren tabel

Der er to tilgange, afhængigt af dit use case:

Mulighed A: Én række pr. variant (bedst til prissporing og lagerovervågning)

1# Brug extract_product_data-funktionen fra trin 4
2products = scrape_all_products("https://allbirds.com")
3rows = extract_product_data(products)
4df = pd.DataFrame(rows)
5print(f"DataFrame-form: {df.shape}")
6print(df.head())

Det giver dig en flad tabel, hvor hver række er en unik kombination af produkt og variant. En butik med 500 produkter og gennemsnitligt 4 varianter pr. produkt giver en DataFrame med omkring 2.000 rækker.

Mulighed B: Én række pr. produktoversigt (bedst til katalogoverblik)

1def summarize_products(products):
2    """Én række pr. produkt med min/max-pris på tværs af varianter."""
3    rows = []
4    for product in products:
5        prices = [float(v["price"]) for v in product.get("variants", []) if v.get("price")]
6        rows.append({
7            "product_id": product["id"],
8            "title": product["title"],
9            "vendor": product.get("vendor", ""),
10            "product_type": product.get("product_type", ""),
11            "variant_count": len(product.get("variants", [])),
12            "min_price": min(prices) if prices else None,
13            "max_price": max(prices) if prices else None,
14            "any_available": any(v.get("available", False) for v in product.get("variants", [])),
15            "tags": ", ".join(product.get("tags", []))
16        })
17    return rows

Eksportér til CSV, Excel og Google Sheets

1# CSV-eksport (brug utf-8-sig, så Excel håndterer specialtegn)
2df.to_csv("shopify_products.csv", index=False, encoding="utf-8-sig")
3# Excel-eksport (kræver openpyxl)
4df.to_excel("shopify_products.xlsx", index=False, engine="openpyxl")
5print("Eksporteret til shopify_products.csv og shopify_products.xlsx")

Til Google Sheets kan du bruge gspread-biblioteket med en servicekonto, men helt ærligt — for de fleste use cases er det hurtigere og nemmere bare at eksportere til CSV og uploade til Google Drive.

Produktionsegnet Python-scraping: Rate limits, retries og anti-blocking

Det grundlæggende script fungerer fint til små butikker. Scraper du en butik med 5.000+ produkter eller rammer flere butikker i træk? Så begynder det at knække.

Forstå Shopifys rate limits og blokeringer

Shopifys offentlige JSON-endpoints har ikke formelt dokumenterede rate limits (i modsætning til Admin API's leaky bucket-model), men empiriske tests viser:

• Sikker hastighed: ca. 2 kald i sekundet pr. butik
• Blød grænse: ca. 40 kald i minuttet, før throttling slår ind
• HTTP 429: “Too Many Requests” — standardrespons ved rate limit
• HTTP 430: En Shopify-specifik kode, der indikerer en sikkerhedsblokering (ikke kun rate limiting)
• HTTP 403 eller CAPTCHA-redirect: Nogle butikker har ekstra Cloudflare-beskyttelse

Kald fra delt cloud-infrastruktur (AWS Lambda, Google Cloud Run) er særligt tilbøjelige til at blive blokeret, fordi disse IP-områder ofte er forbundet med misbrug.

Teknikker til at scrape Shopify pålideligt

Her er udviklingen fra “det virker på min laptop” til “det kører i produktion”:

Mellemniveauet (anbefalet til de fleste brugere):

1import requests
2from requests.adapters import HTTPAdapter
3from urllib3.util.retry import Retry
4> This paragraph contains content that cannot be parsed and has been skipped.
5`Retry`-opsætningen håndterer 429-svar automatisk med eksponentiel backoff. `backoff_factor=1` betyder, at ventetiden bliver 0,5s → 1s → 2s → 4s → 8s mellem forsøgene. Genbrug af session (`requests.Session()`) giver også connection pooling, som reducerer overhead, når du laver flere kald til samme domæne.
6**User-Agent-rotation**: Hvis du scraper flere butikker, så skift mellem 3–5 realistiske browser-User-Agent-strenge. Det handler ikke om at snyde — det handler om ikke at ligne en bot, der sender identiske headere ved hvert eneste kald.
7<iframe width="560" height="315" src="https://www.youtube.com/embed/p3Z-qtUp4p8" title="Webscraping-projekt: Gem Shopify-produkter i en database" frameBorder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowFullScreen></iframe>
8## Fuld fungerende Python-script til Shopify scraping med CSV-eksport
9Her er det komplette script, klar til copy-paste, som samler alt ovenfor. Det er cirka 75 linjer faktisk kode (plus kommentarer), og jeg har testet det mod Allbirds (1.420 produkter), ColourPop (2.000+ produkter) og Zoologist Perfumes (lille katalog).
10```python
11import requests
12import pandas as pd
13import time
14import random
15from requests.adapters import HTTPAdapter
16from urllib3.util.retry import Retry
17> This paragraph contains content that cannot be parsed and has been skipped.
18def scrape_shopify(store_url, delay=1.0):
19    """Scrape alle produkter fra en Shopify-butik via /products.json."""
20    session = create_session()
21    all_products = []
22    page = 1
23    base_url = f"{store_url.rstrip('/')}/products.json"
24> This paragraph contains content that cannot be parsed and has been skipped.
25        if not products:
26            break
27        all_products.extend(products)
28        print(f"{len(products)} produkter (i alt: {len(all_products)})")
29        page += 1
30        time.sleep(delay + random.uniform(0, 0.5))
31    return all_products
32> This paragraph contains content that cannot be parsed and has been skipped.
33if __name__ == "__main__":
34    STORE_URL = "https://allbirds.com"  # Skift til den butik, du vil scrape
35    OUTPUT_CSV = "shopify_products.csv"
36    OUTPUT_EXCEL = "shopify_products.xlsx"
37    print(f"Scraper {STORE_URL}...")
38    products = scrape_shopify(STORE_URL)
39    print(f"\nSamlet antal produkter scraped: {len(products)}")
40    print("Flader til variantniveau-rækker...")
41    rows = flatten_to_variants(products)
42    df = pd.DataFrame(rows)
43    print(f"DataFrame: {df.shape[0]} rækker x {df.shape[1]} kolonner")
44    df.to_csv(OUTPUT_CSV, index=False, encoding="utf-8-sig")
45    df.to_excel(OUTPUT_EXCEL, index=False, engine="openpyxl")
46    print(f"\nEksporteret til {OUTPUT_CSV} og {OUTPUT_EXCEL}")

Kør det med python scrape_shopify.py. For Allbirds tager det omkring 45 sekunder og producerer en CSV med cirka 5.000+ rækker (én pr. variant). Terminal-outputtet ser nogenlunde sådan ud:

1Scraper https://allbirds.com...
2  Side 1... 250 produkter (i alt: 250)
3  Side 2... 250 produkter (i alt: 500)
4  ...
5  Side 6... 170 produkter (i alt: 1420)
6Samlet antal produkter scraped: 1420
7Flader til variantniveau-rækker...
8DataFrame: 5680 rækker x 14 kolonner
9Eksporteret til shopify_products.csv og shopify_products.xlsx

Spring Python over: Scrape Shopify på 2 klik med Thunderbit (no-code alternativ)

Ikke alle gider installere Python, fejlfinde importfejl eller vedligeholde et scraping-script. For en sælger, der skal bruge konkurrentpriser i morgen tidlig, er Python ofte overkill.

Derfor byggede vi — en AI webscraper, der kører som en Chrome-udvidelse. Ingen kode, ingen API-nøgler, ingen miljøopsætning.

Sådan scraper Thunderbit Shopify-butikker

Thunderbit har en dedikeret Shopify Scraper-template, der er forudkonfigureret til Shopify produktsider. Du installerer , går til en Shopify-butik og klikker på “Scrape”. Skabelonen udtrækker automatisk produktnavne, beskrivelser, priser, variantdetaljer, billeder og leverandøroplysninger.

På butikker, hvor skabelonen ikke matcher helt perfekt (custom themes, usædvanlige layouts), kan Thunderbits AI Suggest Fields-funktion læse siden og automatisk foreslå kolonnenavne. Du kan tilpasse dem — omdøbe kolonner, tilføje felter og skrive instruktioner som “udtræk kun produkter med compare_at_price sat.”

Nogle af de funktioner, der direkte matcher det, Python-scriptet gør:

• Undersidescraping: Besøger automatisk hver produktside og beriger tabellen med fulde beskrivelser, anmeldelser eller variantdetaljer — det samme som vores Python-script opnår ved at iterere gennem sider, bare uden kode.
• Automatisk pagination: Håndterer klik-pagination og infinite scroll uden opsætning.
• Planlagt scraping: Sæt tilbagevendende jobs op (fx “hver mandag kl. 9”) til løbende prissporing — uden cron-job eller server.
• Gratis eksport til CSV, Excel, Google Sheets, Airtable eller Notion på tværs af alle planer.

Python-script vs. Thunderbit: Ærlig sammenligning

Brug Python, når du vil have fuld kontrol eller integrerer i en større datapipeline. Brug Thunderbit, når du skal bruge data hurtigt og ikke vil vedligeholde kode. Vil du dykke dybere ned i , har vi en separat guide om emnet.

Tips og best practices til scraping af Shopify-butikker

Det her gælder uanset, hvilket værktøj du bruger:

• Brug altid ?limit=250 for at minimere antallet af requests. Standard på 30 pr. side betyder 8x flere kald for de samme data.
• Respektér butikken: Tilføj 1–2 sekunders pause mellem kald. At hamre en server med lynhurtige requests er dårlig praksis og øger risikoen for blokering.
• Tjek robots.txt først: Shopifys standard robots.txt blokerer ikke /products.json. Men nogle butikker tilføjer egne regler, så verificér det, før du scraper i stor skala.
• Gem rå JSON lokalt først, og processér bagefter. Hvis din parsinglogik ændrer sig senere, behøver du ikke scrape igen. En enkel json.dump(all_products, open("raw_data.json", "w")) før flattening sparer hovedpine.
• Deduplikér på product.id: Pagination-kanter kan nogle gange returnere dubletter ved sideskift. En hurtig df.drop_duplicates(subset=["product_id", "variant_id"]) rydder op.
• Cast price til float, før du laver beregninger. Shopify returnerer priser som strenge ("185.00"), ikke tal.
• Hold øje med endpoint-ændringer: Selvom /products.json har været stabilt i årevis, kan Shopify i princippet begrænse det. Hvis din scraper pludselig får 404, så tjek butikken manuelt først.

Vil du have mere om robuste scrapers, så se vores guide om .

Juridiske og etiske overvejelser ved Shopify scraping

Et kort afsnit, men det betyder noget.

/products.json-endpointet leverer offentligt tilgængelige produktdata — den samme information som enhver besøgende kan se, når de browser butikken. Shopifys vilkår indeholder formuleringer om ikke at bruge “automated means” til at få adgang til “the Services”, men det henviser til selve platformen (admin-dashboard, checkout), ikke offentlige storefront-data. Der er ikke anlagt nogen Shopify-specifikke scraping-sager pr. april 2026.

Vigtige juridiske præcedenser understøtter scraping af offentlige data: hiQ v. LinkedIn fastslog, at scraping af offentligt tilgængelige data ikke bryder CFAA, og Meta v. Bright Data (2024) slog fast, at TOS-restriktioner kun gælder, når en bruger er logget ind.

Best practices:

• Scrape kun offentligt tilgængelige produktdata
• Scrape ikke personlige data eller kundedata
• Respektér robots.txt og rate limits
• Overhold GDPR/CCPA, hvis du håndterer persondata (produktkatalogdata er ikke-personlige)
• Identificér dig med en tydelig User-Agent-streng
• At scrape din egen Shopify-butik via Admin API er altid i orden

Vil du have et dybere juridisk dyk, så se vores indlæg om .

Konklusion og vigtigste pointer

Shopifys offentlige /products.json-endpoint gør udtræk af ecommerce-data næsten så nemt, som det kan blive. Arbejdsgangen er: tilføj /products.json → hent med Python → paginér med ?limit=250&page= → flad ud med pandas → eksporter til CSV eller Excel.

Det her dækker guiden, som andre ikke gør:

• Komplet feltreference: Ved præcis, hvilke data der er tilgængelige (40+ felter på tværs af produkter, varianter og billeder), før du skriver en eneste linje kode
• Ekstra endpoints: /collections.json og /meta.json giver dig indsigt på kategoriniveau og butiksmetadata, som ingen konkurrerende guide dækker
• Produktionsegne teknikker: Genbrug af sessioner, eksponentiel backoff, User-Agent-headere og ?limit=250 til at håndtere virkelige rate limits
• Korrekt CSV/Excel-eksport: Fladgjorte data på variantniveau med pandas, ikke bare rå JSON-dumps
• No-code-alternativ: til brugere, der foretrækker hastighed frem for kodefleksibilitet

Til engangsudtræk eller tilbagevendende Shopify-data uden kode kan du prøve — Shopify Scraper-template’en håndterer alt fra pagination til eksport. Til specialbyggede datapipelines eller scraping i stor skala på tværs af mange butikker giver Python-scriptet i denne guide dig fuld kontrol.

Se også vores for videoguider, eller udforsk vores guides om og for relaterede teknikker.

FAQ

Kan man scrape enhver Shopify-butik med products.json?

De fleste Shopify-butikker eksponerer dette endpoint som standard — i tests returnerede omkring 71 % gyldig JSON. Nogle butikker med custom opsætninger eller ekstra sikkerhedslag (Cloudflare, headless-opsætninger) kan returnere 404 eller blokere forespørgslen. Den hurtige test: besøg {store-url}/products.json i din browser. Hvis du ser JSON, er du klar.

Er det lovligt at scrape Shopify-butikker?

Offentlige produktdata (priser, titler, billeder, beskrivelser) er generelt tilgængelige, og juridiske præcedenser som hiQ v. LinkedIn understøtter scraping af offentligt tilgængelig information. Når det er sagt, bør du altid tjekke den specifikke butiks vilkår og dine lokale love. Scrape ikke personlige data eller kundedata, og respekter rate limits.

Hvor mange produkter kan man scrape fra en Shopify-butik?

Der er ingen fast øvre grænse for det samlede antal. Pagination med ?limit=250&page= gør det muligt at hente hele kataloget. For meget store butikker (25.000+ produkter) bør du bruge session-genbrug og pauser for at undgå rate limits. /meta.json-endpointet kan fortælle dig det præcise produktantal på forhånd, så du ved, hvor mange sider du kan forvente.

Hvad er forskellen mellem products.json og Shopify Admin API?

/products.json er et offentligt endpoint — ingen autentificering, kun læsbare produktdata, og det kan tilgås af alle. Admin API kræver butiksejerens adgangstoken og giver adgang til ordrer, lagerantal, kundedata og skriveadgang. Hvis du har brug for salgsdata eller faktiske lagertal, skal du have Admin API-adgang (hvilket betyder, at du skal være butiksejer eller have tilladelse).

Kan jeg scrape Shopify uden Python?

Helt sikkert. Værktøjer som lader dig scrape Shopify-butikker fra en Chrome-udvidelse uden kode. Det håndterer pagination automatisk og eksporterer direkte til CSV, Excel, Google Sheets, Airtable eller Notion. For udviklere, der foretrækker andre sprog, fungerer det samme /products.json-endpoint med JavaScript, Ruby, Go — ethvert sprog, der kan lave HTTP-kald og parse JSON.

Læs mere