Convierte las interfaces públicas JSON y de sitemap de tiendas Shopify en datos estructurados para monitoreo de catálogo, investigación de surtido, descubrimiento de productos e inteligencia de tiendas.
Salida estructurada
Con la API de Scraping de Tiendas Shopify de Crawlora, recopila JSON público de tienda, productos, colecciones, páginas, recomendaciones, búsqueda predictiva y registros de sitemap, según lo admitido, sin mantener tú mismo el procesamiento de solicitudes específico de Shopify, la normalización de URLs, parsers, facturación o documentación para desarrolladores.
Workflow de e-commerce
Los datos de tiendas Shopify respaldan el descubrimiento público de catálogo, el monitoreo de productos, la investigación de colecciones, el análisis de sugerencias de búsqueda, el descubrimiento de páginas y las auditorías de sitemap para equipos que necesitan registros estructurados reproducibles en lugar de navegar manualmente por la tienda.
Inteligencia de tiendas ShopifyEsquema de la solicitud
Estos parámetros provienen de la entrada activa del catálogo de Get Shopify store metadata.
| Parámetro | Tipo | Obligatorio | Descripción | Ejemplo |
|---|---|---|---|---|
| url | string | Sí | Shopify storefront URL | - |
Ejemplo de JSON
Este ejemplo se renderiza a partir del catálogo de endpoints activo, así que la página se mantiene alineada con Docs y 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
}
}Catálogo de endpoints
/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.
Notas de la respuesta
- 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 } } ```
Herramienta MCP 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. `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 SSR-fallback-transport stores; supplying any of these takes precedence over sortBy/dynamic facet filters.
Notas de la respuesta
- 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. - **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 is driven by a fetch of the requested store's own `/collections/all` page with Shopify's documented `sort_by`/`filter.v.*`/`filter.p.*` query params — not the classic catalog JSON or the SSR-embedded payload — so it works for both classic- and SSR-fallback-transport 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). 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 } ] } } ```
Herramienta MCP shopify_products
/shopify/products/{handle}Returns normalized product detail from Shopify's credential-free product handle `.js` endpoint.
Notas de la respuesta
- 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"}] } } } ```
Herramienta MCP 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.
Notas de la respuesta
- 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).
Herramienta MCP 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.
Notas de la respuesta
- 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 } ] } } ```
Herramienta MCP 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. `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 SSR-fallback-transport stores; supplying any of these takes precedence over sortBy/dynamic facet filters.
Notas de la respuesta
- 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. - **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 is driven by a fetch of this collection's own `/collections/{handle}` page with Shopify's documented `sort_by`/`filter.v.*`/`filter.p.*` query params — not the classic catalog JSON or the SSR-embedded payload — so it works for both classic- and SSR-fallback-transport 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). 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 } ] } } ```
Herramienta MCP shopify_collection_products
/shopify/search/suggestReturns products, collections, and query suggestions from Shopify's credential-free predictive search Ajax endpoint.
Notas de la respuesta
- 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.
Herramienta MCP shopify_search_suggest
/shopify/pagesReturns normalized static pages from a public Shopify `/pages.json` endpoint. Page body HTML is returned as cleaned text only.
Notas de la respuesta
- 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).
Herramienta MCP 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.
Notas de la respuesta
- 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).
Herramienta MCP shopify_page
/shopify/sitemapsReturns child sitemap URLs from a public Shopify `/sitemap.xml` index with inferred sitemap types.
Notas de la respuesta
- 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.
Herramienta MCP shopify_sitemaps
/shopify/sitemap/urlsFetches capped URL entries from Shopify child sitemaps matching the requested type.
Notas de la respuesta
- 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.
Herramienta MCP shopify_sitemap_urls
Ejecución gestionada
Crawlora encapsula los flujos públicos admitidos de JSON y sitemap de tiendas Shopify como endpoints protegidos por API key, con respuestas normalizadas, errores documentados, ejemplos en Playground y facturación por créditos.
Procesamiento de solicitudes específico por endpoint para flujos de tienda, producto, colección, página, recomendaciones, sugerencias de búsqueda y sitemap
Validación de URL que rechaza localhost, redes privadas, link-local y URLs con credenciales
Campos normalizados de producto, colección, página, recomendaciones y sitemap según lo disponible
Resolución de URL de origen para tiendas que exponen datos públicos mediante un dominio myshopify.com descubierto
Comportamiento documentado ante fallos upstream como bloqueo, formato incorrecto, no encontrado o ruta raíz faltante
Las páginas de Docs y Playground se generan a partir del catálogo de endpoints activo actual
Construir o comprar
Usa esta comparación para decidir si mantener infraestructura de scraping internamente o llamar a un endpoint gestionado.
| Requisito | Construcción interna | Crawlora |
|---|---|---|
| Cobertura de endpoints | Mantener scrapers separados para metadatos de tienda, productos, colecciones, páginas, recomendaciones y sugerencias de búsqueda. | Usar la familia documentada de endpoints de tiendas Shopify desde una sola interfaz de API de Crawlora. |
| Manejo de URL y origen | Validar tú mismo URLs de tienda no confiables e implementar tu propia lógica de fallback para dominios de origen públicos. | Usar la validación y el manejo de URL de origen específico por endpoint de Crawlora. |
| Normalización de esquemas | Diseñar tú mismo los modelos de producto, colección, página y recomendaciones. | Obtener ejemplos y esquema JSON normalizados en Docs y Playground. |
| Facturación por uso | Construir tu propio modelo de medición y precios por flujo. | Usar ponderación de endpoints por créditos y seguimiento de uso por API key. |
Crawlora no es la Admin API, Storefront API, Checkout API ni Partner API oficial de Shopify. Crawlora ofrece endpoints de extracción estructurada de datos web públicos para las páginas, JSON y flujos de sitemap públicos de tiendas Shopify admitidas. Si tu caso de uso necesita datos comerciales vinculados a cuenta, pedidos, checkout, registros de clientes, gestión de inventario, gestión de comercios o integraciones oficiales de apps, usa la API oficial de Shopify. Los clientes deben asegurarse de que su uso cumpla con la ley aplicable, los derechos de terceros, los términos de la plataforma, los términos de los comercios y los términos de Crawlora.
APIs relacionadas
Conecta este endpoint con páginas adyacentes de Crawlora de búsqueda, monitoreo, documentación y precios.
Investiga workflows de productos, tiendas, reseñas, categorías, sugerencias y variantes públicas de Shop.app.
AbrirIntegra el monitoreo de productos y resultados de búsqueda de Amazon en workflows de marketplace de e-commerce.
AbrirRecopila datos de productos, búsqueda y vendedores de eBay para reventa e investigación de marketplace.
AbrirDiseña workflows públicos de catálogo, páginas, sugerencias de búsqueda y sitemap de Shopify.
AbrirCombina los datos de tiendas Shopify con workflows más amplios de inteligencia de productos de e-commerce.
AbrirConsulta el uso basado en créditos para Shopify y otros endpoints de marketplace.
AbrirCómo hacer scraping de Shopify
Los endpoints de Shopify de Crawlora son solicitudes GET que aceptan la url de cualquier tienda pública, leyendo las interfaces públicas sin credenciales de Shopify: /shopify/store resuelve la tienda y devuelve metadatos, /shopify/products y /shopify/collections leen las interfaces públicas products.json y collections.json (con page y limit), /shopify/collections/{handle}/products itera una colección, /shopify/products/{handle} devuelve detalles de producto mediante el endpoint .js del handle, /shopify/products/{handle}/recommendations lee la interfaz Ajax de recomendaciones (intent related o complementary), /shopify/search/suggest lee la búsqueda predictiva, /shopify/pages y /shopify/pages/{handle} leen páginas estáticas como texto limpio, /shopify/sitemaps y /shopify/sitemap/urls recorren el índice de sitemap. Para tiendas headless sin la interfaz clásica, hay un fallback que lee los datos de búsqueda embebidos en la propia tienda, lo que además expone parámetros facets, sortBy y filtros por faceta.
GET /shopify/store?url=<URL de la tienda> devuelve metadatos normalizados de la tienda a partir del JSON público sin credenciales. Si un dominio personalizado bloquea products.json, el servicio puede recurrir al dominio público myshopify.com de la tienda.
GET /shopify/products?url=<tienda>&page=1&limit=<n> obtiene el feed público de productos, /shopify/collections obtiene la lista de colecciones, /shopify/collections/{handle}/products obtiene los productos de una colección. Una página vacía devuelve estado 200 con un array vacío — así se detecta el final.
GET /shopify/products/{handle}?url=<tienda> devuelve el detalle completo del producto, GET /shopify/products/{handle}/recommendations (intent=related o complementary) devuelve recomendaciones relacionadas de la tienda; el handle se resuelve automáticamente al id de producto de Shopify.
GET /shopify/sitemaps?url=<tienda> lista los sub-sitemaps con su tipo inferido, /shopify/sitemap/urls?type=products recorre sus entradas, /shopify/search/suggest?q=<term> lee la búsqueda predictiva, /shopify/pages y /shopify/pages/{handle} devuelven páginas estáticas como texto limpio.
Preguntas frecuentes
Respuestas para desarrolladores que evalúan Crawlora para páginas de resultados de búsqueda públicas compatibles.
Sí. Crawlora ofrece endpoints de Shopify para metadatos públicos de tienda, productos, detalles de producto, recomendaciones, colecciones, productos de colección, páginas, sugerencias de búsqueda predictiva, sitemaps y URLs de sitemap admitidos.
No. Crawlora no es la Admin API, Storefront API, Checkout API ni Partner API oficial de Shopify, ni tampoco una integración de app de comercio. Ofrece extracción de datos web públicos para páginas de tiendas Shopify admitidas.
El catálogo actual incluye metadatos de tienda, productos públicos, detalles de producto, recomendaciones, colecciones, productos de colección, páginas públicas, sugerencias de búsqueda predictiva, sub-sitemaps y, según lo admitido, entradas de URL de sitemap con límite de cantidad.
No. Los endpoints de Shopify de Crawlora están orientados exclusivamente a datos públicos de tienda dentro de lo admitido. Para workflows comerciales vinculados a cuenta, pedidos, checkout, clientes o gestión de inventario, usa la API oficial de Shopify.
Sí. En la medida en que los datos públicos de la tienda estén disponibles, los endpoints de productos, detalles de producto, colecciones y productos de colección de Shopify pueden respaldar un monitoreo responsable del catálogo.
Sí. Según lo disponible, los endpoints de sitemap de Shopify pueden listar entradas de sub-sitemap, además de filas de URL con límite de cantidad para tipos de sitemap inferidos como productos, colecciones, páginas, blogs y capacidad de descubrimiento por agentes.
Pasa la url de la tienda al endpoint /shopify/store de Crawlora para resolverla, luego llama a GET /shopify/products, /shopify/collections y /shopify/collections/{handle}/products para recorrer el catálogo, y a /shopify/products/{handle} para el detalle. No se necesitan credenciales de Shopify; estos endpoints leen el JSON público de la tienda Shopify.
En la mayoría de los casos sí. Si un dominio personalizado bloquea esa interfaz, el servicio puede recurrir al dominio público myshopify.com; para tiendas headless que carecen por completo de esa interfaz, se resuelven los datos de búsqueda embebidos en la propia tienda, lo que también expone parámetros facets, sortBy y filtros por faceta.
Solo en tiendas headless servidas mediante el fallback de búsqueda embebida, donde los parámetros de query sortBy y filtros por faceta se reenvían al propio índice de búsqueda de la tienda. Las tiendas clásicas con products.json público no tienen ordenamiento ni filtrado en el servidor; ahí el endpoint /shopify/collections/{handle}/products devuelve un error 400 tipado en lugar de ignorar esos parámetros en silencio.
Pasa la url de la tienda e intent=related o intent=complementary al endpoint /shopify/products/{handle}/recommendations. Tras resolver el handle al id de producto, lee la interfaz Ajax de recomendaciones de Shopify, sin credenciales.
Estos endpoints leen el JSON de tienda y los sitemaps que Shopify expone públicamente sin credenciales. Recopilar estos datos con fines de investigación, monitoreo y análisis de surtido suele ser aceptable si se respetan los términos de la tienda, los límites de tasa y la ley aplicable.
No para desarrolladores en general. La propia Admin API de Shopify solo devuelve los datos de la tienda que emitió su token de acceso; no puede leer el catálogo de otro comerciante. La API Catalog más reciente de Shopify, que normaliza los feeds de productos y precios entre muchas tiendas, es solo por invitación y se evalúa por cada socio (Perplexity fue su primera integración); no existe un registro de autoservicio. Los endpoints de Crawlora, en cambio, leen directamente el products.json, collections.json y las interfaces de búsqueda públicas de cada tienda, por lo que cualquier tienda Shopify pública se puede consultar sin pasar por una revisión de asociación.
Cobertura de la empresa
Shopify Inc. · SHOP
Shopify es operado por Shopify Inc. (SHOP). Los endpoints SEC de Crawlora usan el mismo CIK de esa empresa, así que los filings, datos financieros, transacciones de insiders y participaciones 13F provienen de la misma API key que los endpoints de Shopify de arriba.
Otras plataformas de Shopify Inc. en el catálogo
Guides
Read Crawlora guides and comparisons that use the Shopify API.
Prueba los metadatos de tienda Shopify en Playground, revisa el esquema de respuesta actual en Docs y compara el uso basado en créditos en la página de precios.