Turn public Shopify storefront JSON and sitemap surfaces into structured data for catalog monitoring, merchandising research, product discovery, and storefront intelligence workflows.
Structured output
Use Crawlora's Shopify storefront scraper API to collect supported public storefront JSON, product, collection, page, recommendation, predictive search, and sitemap records without maintaining Shopify-specific request handling, URL normalization, parsers, billing, or developer docs.
Commerce workflows
Shopify storefront data can support public catalog discovery, product monitoring, collection research, search suggestion analysis, page discovery, and sitemap auditing when teams need repeatable structured records instead of manual storefront browsing.
Shopify storefront intelligenceRequest schema
These parameters come from the active Get Shopify store metadata catalog entry.
| Parameter | Type | Required | Description | Example |
|---|---|---|---|---|
| url | string | Yes | Shopify storefront URL | https://www.allbirds.com |
Example JSON
This example is rendered from the active endpoint catalog so the page stays aligned with Docs and Playground.
{
"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
}
}Endpoint catalog
/shopify/storeResolves a public Shopify storefront and returns its metadata.
Response notes
- 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. - For some storefronts, `transport_mode` is `ssr_embedded`; it is omitted entirely for other stores. Responses for these stores may have fewer populated fields (for example `myshopify_domain` and the store-metadata fields are typically unavailable). `transport_mode` allowed values: `ssr_embedded` (only ever present, never any other value; omitted for the classic transport).
MCP tool shopify_store
/shopify/productsReturns products from a public Shopify storefront. 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 (`transport_mode: "ssr_embedded"`) and return an invalid-param error if supplied against a classic store, since classic Shopify storefronts have no server-side sort or filter support. `sort_by`, `min_price`, `max_price`, `product_type`, `in_stock_only`, and `option_`-prefixed params (e.g. `option_size=Small,Medium`) drive a separate, independent mechanism -- Shopify's own native Storefront Filtering collection-page feature (`transport_mode: "storefront_filtered"`) -- which works for both classic and headless stores; supplying any of these takes precedence over sortBy/dynamic facet filters.
Response notes
- 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. - For some storefronts, 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. `transport_mode`, `total_items`, and `total_pages` are omitted entirely for other stores. - When `transport_mode` is `ssr_embedded`, 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 other stores. - **`sortBy` and facet filters apply to `ssr_embedded` stores only.** Rather than silently accepting and ignoring `sortBy` or a facet filter against other stores (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 to an `ssr_embedded` store, 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. - **Storefront Filtering** (`sort_by`/`min_price`/`max_price`/`product_type`/`in_stock_only`/`option_*`) is Shopify's own native collection-page filtering/sorting feature, distinct from the `sortBy`/dynamic-facet-filter pair above. It works for all stores. When any of these params is supplied, the response has `transport_mode: "storefront_filtered"` and echoes back the effective `sort_by`, `min_price`, `max_price`, `product_type`, `in_stock_only`, and `variant_options` that were applied. `facets`/`facets_stats` are populated from the storefront's own filter sidebar when present: `facets` maps a lowercased variant option name (e.g. `size`, `color`) or `product_type` to its value-to-count buckets, and `facets_stats.price` gives the Price slider's own `min`/`max` bounds. `total_pages` is populated only when the collection page itself renders numbered pagination links; a single-page result leaves it unset. Not every Shopify store has this feature enabled — a store without it returns the unfiltered/unsorted collection page, which this endpoint cannot distinguish from "the filter matched everything" without upstream signal. `sortBy` allowed values: `sortLTH`, `sortHTL`, `newest`. `sort_by` allowed values: `manual`, `best-selling`, `title-ascending`, `title-descending`, `price-ascending`, `price-descending`, `created-ascending`, `created-descending`. `transport_mode` allowed values: `ssr_embedded`, `storefront_filtered` (omitted entirely for the classic transport).
MCP tool shopify_products
/shopify/products/{handle}Returns one product from any Shopify storefront, given the store URL and the product handle: title, description, product type, tags, price and compare-at price, availability, options, images, and each variant with its own price, availability and barcode. Prices are in decimal currency units; an unknown handle returns `404`.
Response notes
- Product prices are returned in decimal currency units rather than cent values. - Missing product handles return `404` when Shopify returns not found. - Blocked pages, malformed JSON, and missing product fields return upstream errors. - For some storefronts, 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 other stores. A product for which no detail data is available returns an upstream error. `transport_mode` allowed values: `ssr_embedded` (only ever present, never any other value; omitted for the classic transport).
MCP tool shopify_product
/shopify/products/{handle}/recommendationsReturns recommended products from Shopify's product recommendations.
Response notes
- 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. - For some storefronts, 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 other stores. `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 collections from a public Shopify storefront. Valid empty result pages return `200` with an empty collections array.
Response notes
- Valid empty result pages return `200` with an empty `collections` array. - Blocked pages, malformed JSON, and missing `collections` roots return upstream errors. - For some storefronts, 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. `products_count` and other fields not available for these storefronts are omitted, never fabricated. `transport_mode` is omitted entirely for other stores. - 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).
MCP tool shopify_collections
/shopify/collections/{handle}/productsReturns products from a Shopify collection. `sortBy` and dynamic facet-filter query params (e.g. `fit`, `canonicalColour`) only take effect for headless storefronts (`transport_mode: "ssr_embedded"`) and return an invalid-param error if supplied against a classic store, since classic Shopify storefronts have no server-side sort or filter support. `sort_by`, `min_price`, `max_price`, `product_type`, `in_stock_only`, and `option_`-prefixed params (e.g. `option_size=Small,Medium`) drive a separate, independent mechanism -- Shopify's own native Storefront Filtering collection-page feature (`transport_mode: "storefront_filtered"`) -- which works for both classic and headless stores; supplying any of these takes precedence over sortBy/dynamic facet filters.
Response notes
- 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. - For some storefronts, 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. `transport_mode`, `total_items`, and `total_pages` are omitted entirely for other stores. - When `transport_mode` is `ssr_embedded`, 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 other stores. - **`sortBy` and facet filters apply to `ssr_embedded` stores only.** Rather than silently accepting and ignoring `sortBy` or a facet filter against other stores (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 to an `ssr_embedded` store, 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. - **Storefront Filtering** (`sort_by`/`min_price`/`max_price`/`product_type`/`in_stock_only`/`option_*`) is Shopify's own native collection-page filtering/sorting feature, distinct from the `sortBy`/dynamic-facet-filter pair above. It works for all stores. When any of these params is supplied, the response has `transport_mode: "storefront_filtered"` and echoes back the effective `sort_by`, `min_price`, `max_price`, `product_type`, `in_stock_only`, and `variant_options` that were applied. `facets`/`facets_stats` are populated from the collection page's own filter sidebar when present: `facets` maps a lowercased variant option name (e.g. `size`, `color`) or `product_type` to its value-to-count buckets, and `facets_stats.price` gives the Price slider's own `min`/`max` bounds. `total_pages` is populated only when the collection page itself renders numbered pagination links; a single-page result leaves it unset. Not every Shopify store has this feature enabled — a store without it returns the unfiltered/unsorted collection page, which this endpoint cannot distinguish from "the filter matched everything" without upstream signal. `sortBy` allowed values: `sortLTH`, `sortHTL`, `newest`. `sort_by` allowed values: `manual`, `best-selling`, `title-ascending`, `title-descending`, `price-ascending`, `price-descending`, `created-ascending`, `created-descending`. `transport_mode` allowed values: `ssr_embedded`, `storefront_filtered` (omitted entirely for the classic transport).
MCP tool shopify_collection_products
/shopify/search/suggestReturns predictive search suggestions from any Shopify storefront for a query: matching products, collections and suggested queries. Choose which with `types` (default all three) and cap results per type with `limit` (default 10, max 20). Products carry price, availability, images and options; collections carry title, handle, description and product count.
Response notes
- Products and collections use the same shapes as 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/pagesLists static pages from a Shopify storefront given by the required `url`, paged with `page` (from 1) and `limit` (default 50, max 250). Each has `handle`, `title`, `url`, plain-text `content` and dates. If `transport_mode` is `ssr_embedded`, items hold only `handle`, `url` and `updated_at`.
Response notes
- 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. - For some storefronts, 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. `transport_mode` is omitted entirely for other stores. `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 one static page from any public Shopify storefront, by path `handle` and the required `url` of the store. The response has the page's title, URL, times and its `content` as plain text. Unknown handles return 404. Localhost, private-network and credentialed URLs are rejected.
Response notes
- 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. - For some storefronts, the response includes `transport_mode: "ssr_embedded"`; `content` is plain text rendered from the page's rich-text blocks (marks/formatting are dropped, non-rich-text blocks such as banners are skipped), and `id` is omitted because it is not a Shopify numeric id. `transport_mode` is omitted entirely for other stores. `transport_mode` allowed values: `ssr_embedded` (only ever present, never any other value; omitted for the classic transport).
MCP tool shopify_page
/shopify/sitemapsLists the child sitemaps in a Shopify storefront's sitemap index, for the required `url`. Each has a `loc` and a `type` (`products`, `collections`, `pages`, `blogs`, `agentic_discovery` or `other`) inferred from its URL. Localhost, private-network and credentialed URLs are rejected.
Response notes
- 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/urlsLists URL entries from a Shopify storefront's sitemaps, for the required `url`. `type` filters (`all` by default, `products`, `collections`, `pages`, `blogs`, `agentic_discovery`, `other`) and `limit` caps entries (default 50, max 250). Each has `loc`, `type`, `handle`, `lastmod`, `changefreq` and optional `images`.
Response notes
- 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 wraps supported public Shopify storefront JSON and sitemap flows behind API-key protected endpoints with normalized responses, documented errors, Playground examples, and credit-based usage.
Endpoint-specific request handling for store, product, collection, page, recommendation, search suggestion, and sitemap flows
URL validation that rejects localhost, private network, link-local, and credentialed URLs
Normalized product, collection, page, recommendation, and sitemap fields where available
Source URL resolution for storefronts that expose public data on a discovered myshopify.com domain
Documented upstream failure behavior for blocked, malformed, not-found, or missing-root responses
Docs and Playground pages generated from the active endpoint catalog
Build or buy
Use this comparison to decide whether to maintain scraping infrastructure internally or call a managed endpoint.
| Requirement | Building internally | Crawlora |
|---|---|---|
| Endpoint coverage | Maintain separate collectors for storefront metadata, products, collections, pages, recommendations, search suggestions, and sitemaps. | Use documented Shopify storefront endpoint families from one Crawlora API surface. |
| URL and source handling | Validate untrusted storefront URLs and implement public source-domain fallback logic yourself. | Use Crawlora validation and endpoint-specific source URL handling. |
| Schema normalization | Design product, collection, page, recommendation, and sitemap models yourself. | Receive normalized JSON examples and schemas in Docs and Playground. |
| Usage billing | Build your own metering and per-flow pricing model. | Use credit-based endpoint weights and API-key usage tracking. |
Crawlora is not the official Shopify Admin API, Storefront API, Checkout API, or Partner API. Crawlora provides structured public web data extraction endpoints for supported public Shopify storefront pages, JSON, and sitemap flows. If your use case requires account-scoped commerce data, orders, checkout, customer records, inventory administration, merchant administration, or official app integration, use Shopify's official APIs. Customers are responsible for ensuring their use complies with applicable laws, third-party rights, platform terms, merchant terms, and Crawlora terms.
Related APIs
Connect this endpoint with adjacent Crawlora search, monitoring, docs, and pricing pages.
Research public Shop.app product, shop, review, category, suggestion, and variant workflows.
OpenAdd Amazon product and search result monitoring to marketplace workflows.
OpenCollect eBay item, search, and seller data for resale and marketplace research.
OpenPlan public Shopify catalog, page, search suggestion, and sitemap workflows.
OpenConnect Shopify storefront data with broader commerce product intelligence workflows.
OpenReview credit-based usage for Shopify and other marketplace endpoints.
OpenHow to scrape Shopify
Crawlora's Shopify endpoints are GETs that take any public storefront's url and read Shopify's credential-free surfaces: /shopify/store resolves the storefront and returns metadata, /shopify/products and /shopify/collections read the public products.json and collections.json feeds with page and limit, /shopify/collections/{handle}/products walks one collection, /shopify/products/{handle} returns product detail from the handle .js endpoint, /shopify/products/{handle}/recommendations reads the recommendations Ajax endpoint with an intent of related or complementary, /shopify/search/suggest reads predictive search, /shopify/pages and /shopify/pages/{handle} read static pages as cleaned text, and /shopify/sitemaps and /shopify/sitemap/urls enumerate the sitemap index. Headless storefronts that lack the classic feeds fall back to the storefront's own embedded search payload, which adds facets, sortBy and per-facet filters.
GET /shopify/store?url=<storefront URL> returns normalized store metadata from credential-free storefront JSON. If the vanity domain blocks products.json the service may fall back to the store's public myshopify.com domain.
GET /shopify/products?url=<store>&page=1&limit=<n> for the public product feed, /shopify/collections for collections and /shopify/collections/{handle}/products for one collection. Empty pages return 200 with an empty array, which is how you know you reached the end.
GET /shopify/products/{handle}?url=<store> for full product detail, and /shopify/products/{handle}/recommendations with intent=related or complementary for what the store cross-sells; the handle is resolved to Shopify's product id for you.
GET /shopify/sitemaps?url=<store> lists the child sitemaps with inferred types, /shopify/sitemap/urls?type=products enumerates their entries, /shopify/search/suggest?q=<term> reads predictive search, and /shopify/pages plus /shopify/pages/{handle} return static pages as cleaned text.
FAQ
Answers for developers evaluating Crawlora for supported public search result pages.
Yes. Crawlora provides Shopify endpoints for supported public storefront metadata, products, product detail, recommendations, collections, collection products, pages, predictive search suggestions, sitemaps, and sitemap URLs.
No. Crawlora is not the official Shopify Admin API, Storefront API, Checkout API, Partner API, or merchant app integration. It provides public web data extraction for supported Shopify storefront surfaces.
The active catalog includes store metadata, public products, product detail, recommendations, collections, collection products, public pages, predictive search suggestions, child sitemaps, and capped sitemap URL entries where supported.
No. Crawlora Shopify endpoints are for supported public storefront data only. Use official Shopify APIs for account-scoped commerce, order, checkout, customer, inventory, or merchant administration workflows.
Yes. Shopify products, product detail, collections, and collection product endpoints can support responsible catalog monitoring where public storefront data is available.
Yes. Shopify sitemap endpoints can list child sitemap entries and capped URL rows for products, collections, pages, blogs, agentic discovery, and other inferred sitemap types where available.
Pass the storefront url to Crawlora's /shopify/store endpoint to resolve it, then GET /shopify/products, /shopify/collections and /shopify/collections/{handle}/products to walk the catalog and /shopify/products/{handle} for detail. No Shopify credentials are needed; the endpoints read Shopify's public storefront JSON.
Often, yes. If the vanity domain blocks the feed the service may fall back to the public myshopify.com domain, and for headless storefronts with no feed at all it parses the storefront's own embedded search payload, which also exposes facets, sortBy and per-facet filters.
Only on headless storefronts served through the embedded-search fallback, where sortBy and facet-filter query params are forwarded to the store's search index. Classic stores' public products.json has no server-side sort or filter, and the /shopify/collections/{handle}/products endpoint returns a typed 400 rather than silently ignoring the params there.
GET the /shopify/products/{handle}/recommendations endpoint with the store url and intent=related or intent=complementary. It reads Shopify's credential-free recommendations Ajax endpoint after resolving the handle to a product id.
The endpoints read public storefront JSON and sitemaps that Shopify exposes without credentials. Collecting them for research, monitoring and merchandising analysis is generally permissible when you respect the store's terms, rate limits and applicable law.
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.
Company coverage
Shopify Inc. · SHOP
Shopify is operated by Shopify Inc. (SHOP). Crawlora's SEC endpoints take the same company's CIK, so filings, financials, insider transactions and 13F holdings come from the same API key as the Shopify endpoints above.
Other Shopify Inc. platforms in the catalog
Guides
Read Crawlora guides and comparisons that use the Shopify API.
Test Shopify store metadata in Playground, inspect the current response schema in Docs, and compare credit-based usage on the pricing page.