Öffentliche Shopify-Store-JSON- und Sitemap-Schnittstellen in strukturierte Daten für Katalogmonitoring, Sortimentsforschung, Produktentdeckung und Store-Intelligence-Workflows verwandeln.
Strukturierter Output
Mit Crawloras Shopify-Store-Scraping-API im unterstützten Umfang öffentliches Store-JSON, Produkte, Kollektionen, Seiten, Empfehlungen, Predictive Search und Sitemap-Einträge sammeln, ohne Shopify-spezifische Request-Verarbeitung, URL-Normalisierung, Parser, Abrechnung oder Entwicklerdokumentation selbst zu pflegen.
E-Commerce-Workflow
Shopify-Store-Daten unterstützen öffentliche Katalogentdeckung, Produktmonitoring, Kollektionsforschung, Suchvorschlagsanalyse, Seitenentdeckung und Sitemap-Audits für Teams, die reproduzierbare strukturierte Datensätze statt manuellem Store-Browsing brauchen.
Shopify-Store-IntelligenceRequest-Schema
Diese Parameter stammen aus dem aktiven Get Shopify store metadata-Katalogeintrag.
| Parameter | Typ | Erforderlich | Beschreibung | Beispiel |
|---|---|---|---|---|
| url | string | Ja | Shopify storefront URL | - |
Beispiel-JSON
Dieses Beispiel wird aus dem aktiven Endpunktkatalog gerendert, damit die Seite mit Docs und Playground synchron bleibt.
{
"code": 200,
"msg": "OK",
"data": {
"requested_url": "https://www.allbirds.com",
"source_url": "https://www.allbirds.com",
"domain": "www.allbirds.com",
"source_domain": "www.allbirds.com",
"name": "Allbirds",
"currency": "USD",
"country": "US",
"published_products_count": 638
}
}Endpunktkatalog
/shopify/storeResolves a public Shopify storefront and returns normalized metadata from credential-free storefront JSON. If the vanity domain blocks `/products.json`, the service may fall back to a public `*.myshopify.com` domain discovered from the storefront page.
Hinweise zur Response
- Returns the requested storefront URL plus the resolved source URL used for JSON requests. - Includes `myshopify_domain`, store name, currency, country, and published product/collection counts when `/meta.json` exposes them. - Blocked pages, malformed JSON, missing Shopify roots, and unavailable fallback domains return upstream errors. - If the classic `/products.json` endpoint and `*.myshopify.com` domain resolution are both unavailable (some headless Next.js/React storefronts on a Shopify catalog do not expose either), the service falls back to fetching the storefront's own pages directly and parsing their embedded structured data. When this fallback was used, `transport_mode` is `ssr_embedded`; it is omitted entirely for stores served by the classic catalog JSON. Fallback-mode responses may have fewer populated fields (for example `myshopify_domain` and the `/meta.json`-sourced fields are typically unavailable) since `/meta.json` is also unavailable on these storefronts. `transport_mode` allowed values: `ssr_embedded` (only ever present, never any other value; omitted for the classic transport). Example response: ```json { "code": 200, "msg": "OK", "data": { "requested_url": "https://www.allbirds.com", "source_url": "https://www.allbirds.com", "domain": "www.allbirds.com", "source_domain": "www.allbirds.com", "name": "Allbirds", "currency": "USD", "country": "US", "published_products_count": 638 } } ```
MCP-Tool shopify_store
/shopify/productsReturns normalized products from a public Shopify `/products.json` endpoint. Valid empty result pages return `200` with an empty products array. `sortBy` and dynamic facet-filter query params (e.g. `fit`, `canonicalColour`) only take effect for headless storefronts served via the embedded-SSR-JSON fallback transport (`transport_mode: "ssr_embedded"`) and return an invalid-param error if supplied against a classic-transport store, since Shopify's classic public catalog JSON has no server-side sort or filter support.
Hinweise zur Response
- Valid empty result pages return `200` with an empty `products` array. - Product prices are normalized to decimal currency units. - Blocked pages, malformed JSON, and missing `products` roots return upstream errors. - If the classic `/products.json` endpoint and `*.myshopify.com` domain resolution are both unavailable (some headless Next.js/React storefronts on a Shopify catalog do not expose either), the service falls back to the storefront's own conventional "all products" collection page (`/collections/all`) and parses its embedded search-result payload. When this fallback was used, the response includes `transport_mode: "ssr_embedded"`, `total_items`, and `total_pages` (the storefront's own result-count/page-count metadata), and each product may include additive fields only available from this source: `colour`, `canonical_colour`, `discount_percentage`, `rating`, `rating_count`, `collection_tags`, `labels`, and per-variant `inventory_quantity`. `limit` is still honored as an upper bound on returned items, but the underlying page size is fixed by the storefront (commonly 60) and cannot be requested larger than that in fallback mode. `transport_mode`, `total_items`, and `total_pages` are omitted entirely for stores served by the classic catalog JSON. - When the `ssr_embedded` fallback was used, the response may also include `facets` and `facets_stats`, mirroring the storefront's own filter sidebar for that listing: `facets` maps a facet field name exactly as the storefront names it (for example `fit`, `activities`, `canonicalColour`, `sizeInStock`) to its value-to-count buckets, and `facets_stats` gives `min`/`max`/`avg` for numeric-range fields such as `price` and `discountPercentage`. Both are omitted when the storefront's payload did not include facet data, and always omitted for the classic transport. - **Sort and filters are SSR-fallback only.** Shopify's classic public `/products.json` catalog feed has no server-side sort or filter support at all — confirmed live: requesting the same store's classic JSON with a sort applied returns byte-identical product order to the unsorted request. Rather than silently accepting and ignoring `sortBy` or a facet filter against a classic-transport store (which would look like it worked but wouldn't), this endpoint rejects the request with a `400` invalid-param error whenever `sortBy` or any facet-filter query param is supplied and the resolved store is not `transport_mode: "ssr_embedded"`. - When a sort and/or filters were applied on the SSR-fallback transport, the response echoes back what was actually honored: `sort` (one of the enum values below) and `filters` (a map of facet field name to the array of values that were requested for it, after comma-splitting). Both are omitted when no sort/filter was supplied. - `hitsPerPage` (the storefront's own listing page size, commonly 60) is unaffected by sort/filters; `limit` continues to apply as an upper bound on the returned page. `sortBy` allowed values: `sortLTH`, `sortHTL`, `newest`. `transport_mode` allowed values: `ssr_embedded` (only ever present, never any other value; omitted for the classic transport). Example response: ```json { "code": 200, "msg": "OK", "data": { "store_url": "https://www.allbirds.com", "source_url": "https://www.allbirds.com", "page": 1, "limit": 2, "products": [ { "id": "7188363542608", "handle": "mens-tree-runner-nz-natural-white", "title": "Men's Tree Runner NZ - Natural White (Natural White Sole)", "url": "https://www.allbirds.com/products/mens-tree-runner-nz-natural-white", "price": 100, "available": true } ] } } ```
MCP-Tool shopify_products
/shopify/products/{handle}Returns normalized product detail from Shopify's credential-free product handle `.js` endpoint.
Hinweise zur Response
- Product prices from `.js` responses are normalized from cent values to decimal currency units. - Missing product handles return `404` when Shopify returns not found. - Blocked pages, malformed JSON, and missing product fields return upstream errors. - If the classic product `.js` endpoint and `*.myshopify.com` domain resolution are both unavailable (some headless Next.js/React storefronts on a Shopify catalog do not expose either), the service falls back to fetching the product detail page directly and parsing its embedded structured data — preferring a richer Next.js data block when the storefront exposes one, and falling back further to the page's schema.org JSON-LD `ProductGroup`/`Product` block otherwise. When this fallback was used, the response includes `transport_mode: "ssr_embedded"`, and the product may include additive fields only available from this source: `colour`, `canonical_colour`, `discount_percentage`, `rating`, `rating_count`, `collection_tags`, `labels`, and per-variant `inventory_quantity`. `transport_mode` is omitted entirely for stores served by the classic product `.js` endpoint. A product page that carries neither the richer data block nor a matching JSON-LD block returns an upstream error. `transport_mode` allowed values: `ssr_embedded` (only ever present, never any other value; omitted for the classic transport). Example response: ```json { "code": 200, "msg": "OK", "data": { "store_url": "https://www.allbirds.com", "source_url": "https://www.allbirds.com", "product": { "id": "7188363542608", "handle": "mens-tree-runner-nz-natural-white", "title": "Men's Tree Runner NZ - Natural White (Natural White Sole)", "price": 100, "images": [{"url": "https://cdn.shopify.com/example.jpg"}] } } } ```
MCP-Tool shopify_product
/shopify/products/{handle}/recommendationsReturns normalized recommended products from Shopify's credential-free recommendations Ajax endpoint. The route handle is resolved to a Shopify product id before fetching recommendations.
Hinweise zur Response
- Missing product handles return `404` when Shopify returns not found while resolving the seed product. - Valid empty recommendation arrays return `200` with an empty `products` array. - Blocked pages, malformed JSON, and missing Shopify roots return upstream errors. - If the classic recommendations endpoint and `*.myshopify.com` domain resolution are both unavailable (some headless Next.js/React storefronts on a Shopify catalog do not expose either), the service falls back to fetching the seed product's own detail page (recommendations are embedded there) and parses its embedded recommendation carousels. When this fallback was used, the response includes `transport_mode: "ssr_embedded"`, and each product may include the same additive fields documented for `/shopify/products`: `colour`, `canonical_colour`, `discount_percentage`, `rating`, `rating_count`, `collection_tags`, `labels`, and per-variant `inventory_quantity`. `transport_mode` is omitted entirely for stores served by the classic endpoint. `transport_mode` allowed values: `ssr_embedded` (only ever present, never any other value; omitted for the classic transport).
MCP-Tool shopify_product_recommendations
/shopify/collectionsReturns normalized collections from a public Shopify `/collections.json` endpoint. Valid empty result pages return `200` with an empty collections array.
Hinweise zur Response
- Valid empty result pages return `200` with an empty `collections` array. - Blocked pages, malformed JSON, and missing `collections` roots return upstream errors. - If the classic `/collections.json` endpoint and `*.myshopify.com` domain resolution are both unavailable (some headless Next.js/React storefronts on a Shopify catalog do not expose either), the service falls back to enumerating collections from the storefront's own `collections` sitemap. When this fallback was used, the response includes `transport_mode: "ssr_embedded"`, and `title` is a best-effort derivation from the handle (hyphens become spaces, each word title-cased) — **not** the storefront's real display name, since no other source for it exists in this mode. `products_count` and other classic-only fields are omitted, never fabricated. `transport_mode` is omitted entirely for stores served by the classic catalog JSON. - In this fallback mode, `handle` is derived from the last path segment of the collection URL and is not guaranteed unique: some storefronts nest gender/audience-scoped sub-collections under the same final segment (for example `/collections/all-products/womens` and `/collections/legacy/womens` both derive `handle: "womens"`). Use the item's own `url` to identify a specific nested collection rather than assuming `handle` alone round-trips through `GET /shopify/collections/{handle}/products`. `transport_mode` allowed values: `ssr_embedded` (only ever present, never any other value; omitted for the classic transport). Example response: ```json { "code": 200, "msg": "OK", "data": { "store_url": "https://www.allbirds.com", "source_url": "https://www.allbirds.com", "page": 1, "limit": 2, "collections": [ { "id": "278435758160", "handle": "mens", "title": "Men", "url": "https://www.allbirds.com/collections/mens", "products_count": 24 } ] } } ```
MCP-Tool shopify_collections
/shopify/collections/{handle}/productsReturns normalized products from a public Shopify collection `/products.json` endpoint. `sortBy` and dynamic facet-filter query params (e.g. `fit`, `canonicalColour`) only take effect for headless storefronts served via the embedded-SSR-JSON fallback transport (`transport_mode: "ssr_embedded"`) and return an invalid-param error if supplied against a classic-transport store, since Shopify's classic public catalog JSON has no server-side sort or filter support.
Hinweise zur Response
- Valid empty result pages return `200` with an empty `products` array. - Missing collections return `404` when Shopify returns not found. - Blocked pages, malformed JSON, and missing `products` roots return upstream errors. - If the classic collection `/products.json` endpoint and `*.myshopify.com` domain resolution are both unavailable (some headless Next.js/React storefronts on a Shopify catalog do not expose either), the service falls back to fetching the collection listing page directly (`/collections/{handle}`) and parsing its embedded search-result payload. When this fallback was used, the response includes `transport_mode: "ssr_embedded"`, `total_items`, and `total_pages` (the storefront's own result-count/page-count metadata), and each product may include additive fields only available from this source: `colour`, `canonical_colour`, `discount_percentage`, `rating`, `rating_count`, `collection_tags`, `labels`, and per-variant `inventory_quantity`. `limit` is still honored as an upper bound on returned items, but the underlying page size is fixed by the storefront (commonly 60) and cannot be requested larger than that in fallback mode. `transport_mode`, `total_items`, and `total_pages` are omitted entirely for stores served by the classic catalog JSON. - When the `ssr_embedded` fallback was used, the response may also include `facets` and `facets_stats`, mirroring the collection page's own filter sidebar: `facets` maps a facet field name exactly as the storefront names it (for example `fit`, `activities`, `canonicalColour`, `sizeInStock`) to its value-to-count buckets, and `facets_stats` gives `min`/`max`/`avg` for numeric-range fields such as `price` and `discountPercentage`. Both are omitted when the storefront's payload did not include facet data, and always omitted for the classic transport. - **Sort and filters are SSR-fallback only.** Shopify's classic public collection `/products.json` catalog feed has no server-side sort or filter support at all — confirmed live: requesting the same store's classic JSON with a sort applied returns byte-identical product order to the unsorted request. Rather than silently accepting and ignoring `sortBy` or a facet filter against a classic-transport store (which would look like it worked but wouldn't), this endpoint rejects the request with a `400` invalid-param error whenever `sortBy` or any facet-filter query param is supplied and the resolved store is not `transport_mode: "ssr_embedded"`. - When a sort and/or filters were applied on the SSR-fallback transport, the response echoes back what was actually honored: `sort` (one of the enum values below) and `filters` (a map of facet field name to the array of values that were requested for it, after comma-splitting). Both are omitted when no sort/filter was supplied. - `hitsPerPage` (the storefront's own listing page size, commonly 60) is unaffected by sort/filters; `limit` continues to apply as an upper bound on the returned page. `sortBy` allowed values: `sortLTH`, `sortHTL`, `newest`. `transport_mode` allowed values: `ssr_embedded` (only ever present, never any other value; omitted for the classic transport). Example response: ```json { "code": 200, "msg": "OK", "data": { "store_url": "https://www.allbirds.com", "source_url": "https://www.allbirds.com", "collection": "mens", "page": 1, "limit": 2, "products": [ { "handle": "mens-dasher-nz-ochre", "title": "Men's Tree Dasher 2", "price": 135 } ] } } ```
MCP-Tool shopify_collection_products
/shopify/search/suggestReturns products, collections, and query suggestions from Shopify's credential-free predictive search Ajax endpoint.
Hinweise zur Response
- Products and collections are normalized to the same shapes used by the Shopify product and collection endpoints. - Query suggestions include text and a storefront search URL when Shopify provides one. - Valid empty suggestion arrays return `200` with empty arrays. - Blocked pages, malformed JSON, and missing Shopify roots return upstream errors.
MCP-Tool shopify_search_suggest
/shopify/pagesReturns normalized static pages from a public Shopify `/pages.json` endpoint. Page body HTML is returned as cleaned text only.
Hinweise zur Response
- Page content is cleaned text from Shopify `body_html`; raw HTML is not returned. - Valid empty page arrays return `200` with an empty `pages` array. - Blocked pages, malformed JSON, and missing Shopify roots return upstream errors. - If the classic `/pages.json` endpoint and `*.myshopify.com` domain resolution are both unavailable (some headless Next.js/React storefronts on a Shopify catalog do not expose either), the service falls back to enumerating page handles from the storefront's own `pages` sitemap. When this fallback was used, the response includes `transport_mode: "ssr_embedded"`, and each item only carries `handle`, `url`, and `updated_at` — no `title`, `id`, or `content`. Call `GET /shopify/pages/{handle}` per handle to get full content; this trade-off avoids an unbounded per-page fetch fan-out for large stores. `transport_mode` is omitted entirely for stores served by the classic catalog JSON. `transport_mode` allowed values: `ssr_embedded` (only ever present, never any other value; omitted for the classic transport).
MCP-Tool shopify_pages
/shopify/pages/{handle}Returns normalized page detail from Shopify's credential-free `/pages/{handle}.json` endpoint. Page body HTML is returned as cleaned text only.
Hinweise zur Response
- Page content is cleaned text from Shopify `body_html`; raw HTML is not returned. - Missing page handles return `404` when Shopify returns not found. - Blocked pages, malformed JSON, and missing Shopify roots return upstream errors. - If the classic `/pages/{handle}.json` endpoint and `*.myshopify.com` domain resolution are both unavailable (some headless Next.js/React storefronts on a Shopify catalog do not expose either), the service falls back to fetching the page's own HTML and parsing an embedded Contentful CMS entry. When this fallback was used, the response includes `transport_mode: "ssr_embedded"`; `content` is plain text rendered from the page's Contentful rich-text blocks (marks/formatting are dropped, non-rich-text blocks such as banners are skipped), and `id` is omitted because the source id is a Contentful entry id, not a Shopify numeric id. `transport_mode` is omitted entirely for stores served by the classic endpoint. `transport_mode` allowed values: `ssr_embedded` (only ever present, never any other value; omitted for the classic transport).
MCP-Tool shopify_page
/shopify/sitemapsReturns child sitemap URLs from a public Shopify `/sitemap.xml` index with inferred sitemap types.
Hinweise zur Response
- Sitemap `type` is inferred from the child sitemap URL. - Inferred sitemap types are `products`, `collections`, `pages`, `blogs`, `agentic_discovery`, and `other`. - Blocked pages, malformed XML, and missing sitemap entries return upstream errors.
MCP-Tool shopify_sitemaps
/shopify/sitemap/urlsFetches capped URL entries from Shopify child sitemaps matching the requested type.
Hinweise zur Response
- The service fetches matching child sitemaps from `/sitemap.xml` until `limit` URL entries is reached. - URL entries include `loc`, inferred `type`, `handle`, `lastmod`, `changefreq`, and optional `images`. - Blocked pages, malformed XML, and missing sitemap entries return upstream errors.
MCP-Tool shopify_sitemap_urls
Managed Execution
Crawlora kapselt unterstützte öffentliche Shopify-Store-JSON- und Sitemap-Abläufe als API-Key-geschützte Endpunkte mit normalisierten Antworten, dokumentierten Fehlern, Playground-Beispielen und Credit-basierter Nutzungsabrechnung.
Endpunkt-spezifische Request-Verarbeitung für Store-, Produkt-, Kollektions-, Seiten-, Empfehlungs-, Suchvorschlags- und Sitemap-Abläufe
URL-Validierung, die localhost, private Netzwerke, link-local und URLs mit Credentials ablehnt
Normalisierte Produkt-, Kollektions-, Seiten-, Empfehlungs- und Sitemap-Felder im verfügbaren Umfang
Quell-URL-Auflösung für Stores, die öffentliche Daten über eine entdeckte myshopify.com-Domain bereitstellen
Dokumentiertes Verhalten bei Upstream-Ausfällen wie Blockierung, Fehlformat, Nicht-gefunden oder fehlendem Root-Pfad
Docs- und Playground-Seiten werden aus dem aktuell aktiven Endpunktkatalog generiert
Selbst bauen oder kaufen
Nutze diesen Vergleich, um zu entscheiden, ob du Scraping-Infrastruktur intern pflegst oder einen Managed-Endpunkt aufrufst.
| Anforderung | Eigenbau | Crawlora |
|---|---|---|
| Endpunktabdeckung | Eigene Crawler für Store-Metadaten, Produkte, Kollektionen, Seiten, Empfehlungen und Suchvorschläge pflegen. | Dokumentierte Shopify-Store-Endpunktfamilie über eine Crawlora-API-Oberfläche nutzen. |
| URL- und Quellbehandlung | Nicht vertrauenswürdige Store-URLs selbst validieren und Fallback-Logik für öffentliche Quelldomains selbst implementieren. | Crawloras Validierung und endpunkt-spezifische Quell-URL-Behandlung nutzen. |
| Schema-Normalisierung | Produkt-, Kollektions-, Seiten- und Empfehlungsmodelle selbst entwerfen. | Normalisierte JSON-Beispiele und -Schema in Docs und Playground erhalten. |
| Nutzungsabrechnung | Eigenes Metering- und pro-Ablauf-Preismodell bauen. | Credit-basierte Endpunkt-Gewichtung und API-Key-Nutzungstracking verwenden. |
Crawlora ist nicht Shopifys offizielle Admin API, Storefront API, Checkout API oder Partner API. Crawlora bietet strukturierte Web-Extraktion öffentlicher Daten für unterstützte öffentliche Shopify-Store-Seiten, -JSON und -Sitemap-Abläufe. Wenn dein Use Case konto-gebundene Commerce-Daten, Bestellungen, Checkout, Kundendatensätze, Bestandsverwaltung, Händlerverwaltung oder offizielle App-Integrationen benötigt, nutze Shopifys offizielle API. Kund:innen müssen selbst sicherstellen, dass ihre Nutzung geltendem Recht, Rechten Dritter, Plattformbedingungen, Händlerbedingungen und den Crawlora-Bedingungen entspricht.
Verwandte APIs
Verbinde diesen Endpunkt mit angrenzenden Crawlora-Seiten für Suche, Monitoring, Docs und Preise.
Öffentliche Shop.app-Produkt-, Store-, Review-, Kategorie-, Vorschlags- und Variantendaten-Workflows recherchieren.
ÖffnenAmazon-Produkt- und Suchergebnismonitoring in E-Commerce-Marktplatz-Workflows einbinden.
ÖffneneBay-Produkt-, Such- und Verkäuferdaten für Resale- und Marktplatzforschung sammeln.
ÖffnenÖffentliche Shopify-Katalog-, Seiten-, Suchvorschlags- und Sitemap-Workflows planen.
ÖffnenShopify-Store-Daten mit breiteren E-Commerce-Produkt-Intelligence-Workflows kombinieren.
ÖffnenCredit-basierte Nutzung für Shopify und weitere Marktplatz-Endpunkte ansehen.
ÖffnenSo scrapst du Shopify
Crawloras Shopify-Endpunkte sind GET-Requests, die die url eines beliebigen öffentlichen Stores akzeptieren und Shopifys credential-freie öffentliche Schnittstellen auslesen: /shopify/store löst den Store auf und liefert Metadaten, /shopify/products und /shopify/collections lesen die öffentlichen products.json- und collections.json-Schnittstellen (mit page und limit), /shopify/collections/{handle}/products iteriert über eine Kollektion, /shopify/products/{handle} liefert Produktdetails über den .js-Endpunkt des Handles, /shopify/products/{handle}/recommendations liest die Empfehlungs-Ajax-Schnittstelle (intent related oder complementary), /shopify/search/suggest liest die Predictive Search, /shopify/pages und /shopify/pages/{handle} lesen statische Seiten als bereinigten Text, /shopify/sitemaps und /shopify/sitemap/urls iterieren über den Sitemap-Index. Bei Headless-Stores ohne klassische Schnittstelle greift ein Fallback auf die im Store selbst eingebetteten Suchdaten zurück, der zusätzlich facets-, sortBy- und Facettenfilter-Parameter liefert.
GET /shopify/store?url=<Store-URL> liefert normalisierte Store-Metadaten aus dem credential-freien Store-JSON. Blockiert eine Custom-Domain products.json, kann der Dienst auf die öffentliche myshopify.com-Domain des Stores zurückfallen.
GET /shopify/products?url=<store>&page=1&limit=<n> liefert den öffentlichen Produkt-Feed, /shopify/collections die Kollektionsliste, /shopify/collections/{handle}/products die Produkte einer Kollektion. Eine leere Seite liefert Status 200 mit leerem Array — so erkennst du das Ende.
GET /shopify/products/{handle}?url=<store> liefert vollständige Produktdetails, GET /shopify/products/{handle}/recommendations (intent=related oder complementary) liefert verwandte Empfehlungen des Stores; der handle wird automatisch zur Shopify-Produkt-id aufgelöst.
GET /shopify/sitemaps?url=<store> listet Sub-Sitemaps mit abgeleitetem Typ, /shopify/sitemap/urls?type=products iteriert deren Einträge, /shopify/search/suggest?q=<term> liest Predictive Search, /shopify/pages sowie /shopify/pages/{handle} liefern statische Seiten als bereinigten Text.
FAQ
Antworten für Entwickler, die Crawlora für unterstützte öffentliche Suchergebnisseiten evaluieren.
Ja. Crawlora bietet Shopify-Endpunkte für unterstützte öffentliche Store-Metadaten, Produkte, Produktdetails, Empfehlungen, Kollektionen, Kollektionsprodukte, Seiten, Predictive-Search-Vorschläge, Sitemaps und Sitemap-URLs.
Nein. Crawlora ist nicht Shopifys offizielle Admin API, Storefront API, Checkout API, Partner API und auch keine Händler-App-Integration. Sie bietet öffentliche Web-Datenextraktion für unterstützte Shopify-Store-Seiten.
Der aktuelle Katalog umfasst Store-Metadaten, öffentliche Produkte, Produktdetails, Empfehlungen, Kollektionen, Kollektionsprodukte, öffentliche Seiten, Predictive-Search-Vorschläge, Sub-Sitemaps und im unterstützten Umfang mengenbegrenzte Sitemap-URL-Einträge.
Nein. Crawloras Shopify-Endpunkte zielen ausschließlich auf öffentliche Store-Daten im unterstützten Umfang. Für konto-gebundene Commerce-, Bestell-, Checkout-, Kunden- oder Bestandsverwaltungs-Workflows nutze Shopifys offizielle API.
Ja. Soweit öffentliche Store-Daten verfügbar sind, unterstützen Shopifys Produkt-, Produktdetail-, Kollektions- und Kollektionsprodukt-Endpunkte verantwortungsvolles Katalogmonitoring.
Ja. Soweit verfügbar, können Shopify-Sitemap-Endpunkte Sub-Sitemap-Einträge sowie mengenbegrenzte URL-Zeilen für abgeleitete Sitemap-Typen wie Produkte, Kollektionen, Seiten, Blogs und Agent-Discoverability auflisten.
Übergib die url des Stores an Crawloras /shopify/store-Endpunkt, um ihn aufzulösen, dann rufe GET /shopify/products, /shopify/collections und /shopify/collections/{handle}/products auf, um den Katalog zu durchlaufen, und /shopify/products/{handle} für Details. Keine Shopify-Credentials nötig — diese Endpunkte lesen Shopifys öffentliches Store-JSON.
Meist ja. Blockiert eine Custom-Domain diese Schnittstelle, kann der Dienst auf die öffentliche myshopify.com-Domain zurückfallen; bei Headless-Stores ganz ohne diese Schnittstelle werden die im Store eingebetteten Suchdaten ausgelesen, was zusätzlich facets-, sortBy- und Facettenfilter-Parameter offenlegt.
Nur bei Headless-Stores, die über den eingebetteten Such-Fallback bedient werden — dort werden sortBy und Facettenfilter-Query-Parameter an den eigenen Suchindex des Stores weitergereicht. Klassische Stores mit öffentlicher products.json haben keine serverseitige Sortierung oder Filterung; dort liefert der Endpunkt /shopify/collections/{handle}/products einen typisierten 400-Fehler, statt diese Parameter still zu ignorieren.
Übergib an /shopify/products/{handle}/recommendations die Store-url sowie intent=related oder intent=complementary. Nach Auflösung des handle zur Produkt-id liest der Endpunkt Shopifys credential-freie Empfehlungs-Ajax-Schnittstelle.
Diese Endpunkte lesen Shopifys öffentlich ohne Credentials zugängliches Store-JSON und Sitemaps. Das Sammeln dieser Daten für Recherche, Monitoring und Sortimentsanalyse ist im Rahmen der Store-Bedingungen, Ratenlimits und geltenden Rechts in der Regel zulässig.
Not for general developers. Shopify's own Admin API only returns the data for the store that issued its access token — it can't read another merchant's catalog. Shopify's newer cross-store Catalog API, which normalizes product and pricing feeds across many stores, is invite-only and vetted per partner (Perplexity was its first integration); there is no self-serve signup. Crawlora's endpoints instead read each storefront's own public products.json, collections.json, and search surfaces directly, so any public Shopify store is queryable without a partnership review.
Unternehmensabdeckung
Shopify Inc. · SHOP
Shopify wird von Shopify Inc. (SHOP) betrieben. Crawloras SEC-Endpunkte nutzen dieselbe CIK dieses Unternehmens, sodass Filings, Finanzdaten, Insider-Transaktionen und 13F-Beteiligungen mit demselben API-Key wie die Shopify-Endpunkte oben abrufbar sind.
Weitere Shopify Inc.-Plattformen im Katalog
Guides
Read Crawlora guides and comparisons that use the Shopify API.
Teste Shopify-Store-Metadaten im Playground, sieh dir das aktuelle Response-Schema in den Docs an und vergleiche die Credit-basierte Nutzung auf der Preisseite.