Shopify Products Scraper | Prices & Variants

Extract complete public product catalogs from one or more Shopify stores. Add the storefront URLs and receive one clean Dataset row per product, including titles, vendors, product types, descriptions, prices, compare-at prices, availability, variants, SKUs, barcodes, options, images, tags, and timestamps.

The Actor automatically paginates through each store, removes duplicate products, handles temporary rate limits, and preserves results from successful stores when another store fails. No Shopify account, Shopify API key, collection URL, product URL list, or technical performance configuration is required.

This is an independent, unofficial tool and is not affiliated with or endorsed by Shopify.

What can you use this Shopify Products Scraper for?

• Competitor price monitoring: compare current and compare-at prices, find price ranges, and detect products or variants that are no longer available.
• Catalog and assortment analysis: compare vendors, product types, tags, variants, images, and product counts across stores.
• Product research: create structured product datasets for analysis, sourcing, merchandising, or catalog planning.
• Multi-store comparison: process several Shopify storefronts in one run and identify the source store on every product row.
• New and updated product tracking: use product publication and update timestamps to compare scheduled runs.
• Data export: download the Dataset as JSON, CSV, Excel, XML, or RSS for spreadsheets, databases, dashboards, and other workflows.

What product data can be extracted?

Each Dataset item represents one Shopify product. Depending on the selected output options, it can contain:

• Product ID, title, handle, product URL, store URL, and store domain
• Vendor, product type, tags, plain-text description, and original HTML description
• Minimum and maximum variant prices
• Minimum and maximum compare-at prices
• Storefront currency when it can be confirmed
• Overall product availability
• Variant IDs, titles, SKUs, barcodes, prices, compare-at prices, and availability
• Variant option values such as size, color, or material
• Weight, shipping, tax, and inventory-management signals exposed by the storefront
• Product options and their possible values
• Image URLs, dimensions, positions, alternative text, and associated variant IDs
• Creation, publication, update, and extraction timestamps
• Warnings when the public Shopify data indicates possible incomplete variant coverage

Product and variant IDs are returned as strings so their exact values are preserved. Prices are also returned as decimal strings to avoid floating-point rounding.

Pricing

The Actor costs $1 per 1,000 successfully extracted products, equivalent to $0.001 per product.

You are charged only when a unique product is successfully saved to the Dataset:

Products saved	Product charge
100	$0.10
500	$0.50
1,000	$1.00
10,000	$10.00

There is no Actor start fee, no per-store fee, and no charge for failed, blocked, invalid, or duplicate products. Platform usage is included. If the run reaches your maximum spending limit, the Actor stops adding chargeable products.

How to scrape Shopify products

1. Open the Input tab.
2. Add one or more public Shopify storefront URLs.
3. Choose the maximum number of products per store and for the whole run.
4. Select which optional product data you want included.
5. Click Start.
6. Open the Dataset to view or export the products.

The default settings include variants, images, description HTML, and storefront currency detection. They are suitable for most runs.

Input example

{
  "startUrls": [
    {
      "url": "https://partakefoods.com"
    },
    {
      "url": "https://www.greats.com"
    }
  ],
  "maxProductsPerStore": 500,
  "maxTotalProducts": 800,
  "respectRobotsTxt": true,
  "fetchStorefrontContext": true,
  "includeVariants": true,
  "includeImages": true,
  "includeDescriptionHtml": true,
  "outputMode": "normalized"
}

Input fields

Field	Required	Default	Description
startUrls	Yes	—	Between 1 and 100 public Shopify storefront homepages or localized storefront URLs. Duplicate URLs are processed once.
maxProductsPerStore	No	1000	Maximum unique products saved from each store. Accepted range: 1–100,000.
maxTotalProducts	No	10000	Maximum unique products saved across the entire run. Accepted range: 1–100,000.
respectRobotsTxt	No	true	When enabled, skips a store if its crawler rules disallow access to the public product feed.
fetchStorefrontContext	No	true	Attempts to identify the currency presented by each storefront. Product extraction continues if currency cannot be confirmed.
includeVariants	No	true	Adds nested variant and product-option data.
includeImages	No	true	Adds nested product image metadata and URLs.
includeDescriptionHtml	No	true	Keeps the original HTML description in addition to the cleaned plain-text description.
outputMode	No	normalized	Selects the stable normalized output or normalized output plus the original public Shopify product object.

Shopify store URLs

Use public storefront URLs, for example:

• https://example-store.com
• https://www.example-store.com
• https://example-store.myshopify.com
• https://example-store.com/en-us

The Actor accepts normal custom domains and public myshopify.com domains. It does not accept store administration pages, URLs containing credentials, localhost addresses, or private network addresses.

Product limits

maxProductsPerStore limits each individual store. maxTotalProducts limits the complete run. The run stops at whichever limit is reached first.

For example, with three stores, maxProductsPerStore: 100 and maxTotalProducts: 200, the Actor can save at most 100 products from any one store and at most 200 products in total.

The final count can be lower when:

• A store contains fewer public products than the selected limit
• Products are duplicated or missing required identifiers
• A storefront is password-protected, blocked, unavailable, or not compatible
• robots.txt disallows access and respectRobotsTxt is enabled
• The run reaches its maximum spending limit

Output mode

• normalized is recommended for most users. It returns a consistent field structure that is easier to export, compare, and import elsewhere.
• normalizedAndRaw returns the normalized fields and adds rawProduct, containing the original public Shopify product object. This produces larger Dataset items and is useful only when you need source fields that are not part of the normalized output.

Optional data and Dataset size

Disabling includeVariants, includeImages, or includeDescriptionHtml reduces Dataset size. The product row and its core pricing, availability, identity, source, and timestamp fields remain available.

Output example

Each Dataset item represents one product:

{
  "productKey": "www.greats.com:1234567890",
  "shopifyProductId": "1234567890",
  "storeUrl": "https://www.greats.com",
  "storeDomain": "www.greats.com",
  "productUrl": "https://www.greats.com/products/classic-leather-sneaker",
  "title": "Classic Leather Sneaker",
  "handle": "classic-leather-sneaker",
  "vendor": "Example Brand",
  "productType": "Sneakers",
  "descriptionText": "A versatile leather sneaker designed for everyday wear.",
  "descriptionHtml": "<p>A versatile leather sneaker designed for everyday wear.</p>",
  "tags": [
    "Leather",
    "Sneakers",
    "Men"
  ],
  "available": true,
  "currency": "USD",
  "priceMin": "119.00",
  "priceMax": "129.00",
  "compareAtPriceMin": "149.00",
  "compareAtPriceMax": "149.00",
  "variantCountObserved": 2,
  "variantsMayBeTruncated": false,
  "variants": [
    {
      "id": "9876543210",
      "title": "US 9 / White",
      "sku": "CLS-09-WHT",
      "barcode": "0123456789012",
      "available": true,
      "price": "119.00",
      "compareAtPrice": "149.00",
      "option1": "US 9",
      "option2": "White",
      "option3": null,
      "grams": 850,
      "weight": 0.85,
      "weightUnit": "kg",
      "requiresShipping": true,
      "taxable": true,
      "inventoryManagement": "shopify",
      "featuredImage": null
    },
    {
      "id": "9876543211",
      "title": "US 10 / White",
      "sku": "CLS-10-WHT",
      "barcode": "0123456789013",
      "available": false,
      "price": "129.00",
      "compareAtPrice": "149.00",
      "option1": "US 10",
      "option2": "White",
      "option3": null,
      "grams": 880,
      "weight": 0.88,
      "weightUnit": "kg",
      "requiresShipping": true,
      "taxable": true,
      "inventoryManagement": "shopify",
      "featuredImage": null
    }
  ],
  "options": [
    {
      "name": "Size",
      "position": 1,
      "values": [
        "US 9",
        "US 10"
      ]
    },
    {
      "name": "Color",
      "position": 2,
      "values": [
        "White"
      ]
    }
  ],
  "images": [
    {
      "id": "1111111111",
      "src": "https://cdn.shopify.com/s/files/example/classic-sneaker.jpg",
      "altText": "White classic leather sneaker",
      "width": 1600,
      "height": 1600,
      "position": 1,
      "variantIds": [
        "9876543210",
        "9876543211"
      ]
    }
  ],
  "createdAt": "2025-03-10T09:00:00Z",
  "publishedAt": "2025-03-12T09:00:00Z",
  "updatedAt": "2026-07-29T14:30:00Z",
  "scrapedAt": "2026-07-30T10:00:00+00:00",
  "source": {
    "endpoint": "https://www.greats.com/products.json?limit=100&page=1",
    "page": 1,
    "contract": "public_products_json_observed"
  },
  "warnings": []
}

Fields that the storefront does not provide are returned as null, empty arrays, or omitted when their corresponding output option is disabled.

Output field reference

Identity and source

Field	Description
productKey	Stable combination of store domain and Shopify product ID, used to prevent duplicates.
shopifyProductId	Shopify product identifier returned as a string.
storeUrl	Normalized storefront URL used for the product.
storeDomain	Store hostname, useful for grouping multi-store results.
productUrl	Direct public product-page URL.
handle	Storefront product handle used in the product URL.
source	Public source URL, catalog page number, and observed source contract.

Product content

Field	Description
title	Product title.
vendor	Product vendor or brand when supplied by the merchant.
productType	Merchant-defined Shopify product type.
descriptionText	Product description converted to plain text.
descriptionHtml	Original HTML description when includeDescriptionHtml is enabled.
tags	Merchant-defined product tags.

Pricing and availability

Field	Description
available	true when at least one observed variant is reported as available.
currency	Currency presented by the storefront, or null when it cannot be confirmed.
priceMin, priceMax	Lowest and highest observed variant prices.
compareAtPriceMin, compareAtPriceMax	Lowest and highest observed compare-at prices, or null when none are supplied.
variantCountObserved	Number of variants present in the public product record.
variantsMayBeTruncated	true when 250 variants are observed and additional variants may exist.

Availability is a public purchase-availability signal, not an exact inventory quantity.

Variants, options, and images

Field	Description
variants	Nested variant records with IDs, SKUs, barcodes, prices, availability, option values, weight, shipping, tax, inventory-management, and image information.
options	Product option names and possible values, such as Size and Color.
images	Product image URLs and available metadata, including dimensions, positions, alt text, and related variant IDs.

variants and options are omitted when includeVariants is disabled. images is omitted when includeImages is disabled.

Timestamps and diagnostics

Field	Description
createdAt	Product creation timestamp supplied by the storefront.
publishedAt	Product publication timestamp supplied by the storefront.
updatedAt	Product update timestamp supplied by the storefront.
scrapedAt	Timestamp when the product record was extracted.
warnings	Machine-readable warnings about the product record.
rawProduct	Original public Shopify object, included only in normalizedAndRaw mode.

Run summary and storefront errors

In addition to the product Dataset, the Output tab provides:

• Run summary: overall status, duration, requested and successful stores, stores with results, products saved, whether the product limit was reached, error count, and per-store statistics.
• Storefront errors: a compact list containing the store URL, error category, and HTTP status when available.

Per-store statistics can show products received and saved, duplicates, invalid products, pages, retries, rate limits, currency, warnings, and the final store status.

A run can be marked partial when it preserves valid products but cannot complete every store or reaches a run-wide limit. One failed store does not remove products already saved from another store.

Automatic reliability and performance

No performance or networking knowledge is required. The Actor automatically manages:

• Catalog pagination
• Safe multi-store concurrency
• Request pacing and timeouts
• Retries with increasing delays
• Rate-limit handling
• Duplicate detection
• Repeated-page detection
• Response-size protection
• Independent store failures and partial results

These settings are intentionally automatic so users only need to choose stores, limits, compliance, and output data.

Data availability and limitations

The Actor can return only data exposed by a store through its public Shopify catalog.

• Draft, private, password-protected, unlisted, wholesale-only, or market-restricted products may not appear.
• Exact inventory quantities, product costs, private metafields, customers, and orders are not public catalog data and are not returned.
• Reviews, ratings, sales estimates, collections, and analytics are not extracted.
• Availability indicates whether an observed variant can be purchased; it is not an inventory count.
• Public Shopify product data can expose at most 250 variants for a product. Records at that boundary are marked with variantsMayBeTruncated: true.
• Headless or heavily customized Shopify storefronts may not expose a compatible public catalog.
• Non-Shopify platforms such as WooCommerce, Magento, BigCommerce, Amazon, or custom stores are not supported.
• Currency may depend on the storefront market and visitor context. It remains null when it cannot be confirmed.
• Very active catalogs can change during a run, so results are not a transactional snapshot.
• A store may temporarily block, throttle, redirect, or restrict catalog access.

Frequently asked questions

Does the Actor return every product from a Shopify store?

It returns the products made available through the store's public Shopify catalog, up to the limits you select. Private, hidden, draft, password-protected, or market-restricted products are not available.

Does one Dataset row represent a product or a variant?

One row represents one product. When variants are enabled, all observed variants are nested in the product's variants array.

Can I scrape multiple Shopify stores in one run?

Yes. Add up to 100 URLs to startUrls. Each output item includes storeUrl and storeDomain, so results can be grouped by store.

Why did the run return fewer products than my limit?

The selected value is a maximum, not a guaranteed count. The public catalog may be smaller, contain duplicates or invalid records, be restricted, or become unavailable. The run can also stop at the run-wide product limit or your maximum spending limit. Check the run summary for the final status of each store.

Why is currency null?

Currency detection is separate from product extraction. If the storefront does not expose a verifiable currency context, the Actor keeps the products and returns null instead of guessing.

Does available: true show how many units are in stock?

No. It means at least one observed variant is publicly reported as available for purchase. Shopify does not expose exact inventory quantities in the public product catalog.

What happens if one store fails?

Other stores continue independently. Products already saved remain in the Dataset, and the summary identifies the failed or partial store.

Am I charged when a store fails or returns no products?

No. Charges are created only for unique products successfully saved to the Dataset.

Which output mode should I choose?

Use normalized unless you specifically need the original Shopify object. It is smaller and easier to compare between stores and runs. Choose normalizedAndRaw when retaining all available source fields is more important than Dataset size.

Can I export the results?

Yes. Use the Dataset export controls to download JSON, CSV, Excel, XML, or RSS.

Responsible use

Use the data only for purposes you are authorized to perform. Comply with storefront terms, robots.txt preferences, intellectual-property rights, privacy requirements, and applicable laws.