Shopify Products Scraper

Extract public product catalogs from Shopify storefronts.

Use this actor to collect product titles, handles, prices, compare-at prices, variants, images, vendors, product types, tags, availability, and source URLs from one or more Shopify stores.

What does Shopify Products Scraper do?

Shopify Products Scraper turns public storefront catalogs into clean datasets.

It accepts Shopify store homepages and returns one row per product.

You can run a quick sample for a single brand or collect larger catalogs across multiple stores.

The output is designed for spreadsheets, dashboards, price monitoring, product intelligence, and catalog QA.

Who is it for?

🛒 Ecommerce analysts use it to compare product catalogs across brands.

📈 Agencies use it to build market and assortment reports for clients.

🏷️ Brand operators use it to audit pricing, variants, images, and availability.

🤖 Automation teams use it to feed product data into workflows, alerts, and databases.

🧾 Researchers use it to create structured product datasets without manual copying.

Why use this actor?

It is simple: enter storefront domains and get product rows.

It supports multi-store runs.

It saves variant-level prices and availability when requested.

It includes image URLs for merchandising review.

It returns clear error rows when a store does not expose a public catalog.

It can be scheduled from Apify, called from an API, or connected to integrations.

Typical use cases

Price monitoring across competing Shopify stores.

Assortment tracking for categories, tags, product types, or vendors.

Variant and SKU exports for catalog review.

Image URL extraction for merchandising audits.

Availability checks for products and variants.

New product discovery from public storefront catalogs.

Input overview

The main input is storeUrls.

You can enter URLs such as https://www.deathwishcoffee.com.

The actor normalizes each value to a storefront origin before scraping.

Input fields

Field	Type	Description
storeUrls	array	Shopify storefront URLs or domains to scrape.
maxProductsPerStore	integer	Maximum products to save from each store.
includeVariants	boolean	Include variant details such as SKU, price, and availability.
includeImages	boolean	Include product image URLs and dimensions.
includeRawProduct	boolean	Include the raw product payload for advanced processing.
proxyConfiguration	object	Optional proxy settings for stores that block direct requests.

Example input

{
  "storeUrls": [
    { "url": "https://www.deathwishcoffee.com" },
    { "url": "https://www.brooklinen.com" }
  ],
  "maxProductsPerStore": 25,
  "includeVariants": true,
  "includeImages": true,
  "includeRawProduct": false
}

Output overview

The default dataset contains one row per product.

If a store cannot be read, the dataset includes an error row for that store.

Successful product rows have status set to success.

Store failure rows have status set to error and include errorMessage.

Output fields

Field	Description
status	success or error.
storeUrl	Normalized store origin.
storeDomain	Store hostname.
productId	Shopify product ID.
title	Product title.
handle	Product handle.
url	Product page URL.
vendor	Product vendor.
productType	Product type.
tags	Product tags.
publishedAt	Product publish timestamp when available.
updatedAt	Product update timestamp when available.
priceMin	Lowest variant price.
priceMax	Highest variant price.
compareAtPriceMin	Lowest compare-at price.
compareAtPriceMax	Highest compare-at price.
currency	Currency when inferable.
available	True if at least one variant is available.
variantCount	Number of variants.
imageCount	Number of images.
variants	Optional variant detail array.
images	Optional image detail array.
sourceUrl	Catalog page used for this product.
scrapedAt	Timestamp of extraction.
errorMessage	Error text for failed stores.
rawProduct	Optional original product object.

Variant fields

Variant objects can include ID, title, SKU, price, compare-at price, availability, and selected options.

This is useful when a product has sizes, colors, bundles, or subscriptions.

Variant fields can be disabled to keep datasets smaller.

Image fields

Image objects can include ID, URL, alt text, width, height, and position.

Image fields can be disabled when you only need pricing and catalog metadata.

How much does it cost to scrape Shopify products?

This actor uses pay-per-event pricing.

There is a small start charge for each run.

Each successfully saved product is charged as a product result.

Keep the first run small by using the default prefill or a low maxProductsPerStore value.

Large catalogs cost more because they produce more product rows.

How to run in Apify Console

Open the actor page.

Click Try for free or Start.

Paste one or more Shopify store URLs.

Choose the maximum products per store.

Select whether to include variants and images.

Start the run.

Download results from the Dataset tab as JSON, CSV, Excel, XML, or RSS.

Tips for best results

Start with one store and a small product limit.

Increase maxProductsPerStore after confirming the store returns the expected data.

Use full storefront domains instead of product URLs.

Disable raw product output unless you need original source payloads.

Disable images or variants if you want smaller exports.

Check status and errorMessage for stores that do not expose a public catalog.

Handling stores that fail

Some Shopify stores disable public catalog access.

Some stores use security rules that block automated catalog requests.

This actor reports those stores as error rows instead of hiding failures.

For failed stores, try a smaller run first and verify the domain is the storefront homepage.

If a store still fails, it may not support public catalog extraction.

Scheduling workflows

You can schedule the actor daily, weekly, or monthly in Apify.

Scheduled runs are useful for price monitoring.

They are also useful for detecting catalog changes, new products, or availability updates.

Export each run to your warehouse or compare datasets between runs.

Integrations

Send product rows to Google Sheets for category review.

Send price and availability changes to Slack alerts.

Load datasets into BigQuery, Snowflake, or PostgreSQL.

Trigger Make or Zapier workflows after each run.

Use webhooks to notify your own backend when a catalog scrape finishes.

API usage with Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/shopify-products-scraper').call({
  storeUrls: [{ url: 'https://www.deathwishcoffee.com' }],
  maxProductsPerStore: 25,
  includeVariants: true,
  includeImages: true
});

console.log(run.defaultDatasetId);

API usage with Python

from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/shopify-products-scraper').call(run_input={
    'storeUrls': [{'url': 'https://www.deathwishcoffee.com'}],
    'maxProductsPerStore': 25,
    'includeVariants': True,
    'includeImages': True,
})
print(run['defaultDatasetId'])

API usage with cURL

curl -X POST "https://api.apify.com/v2/acts/fetch_cat~shopify-products-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"storeUrls":[{"url":"https://www.deathwishcoffee.com"}],"maxProductsPerStore":25}'

MCP usage

Use Apify MCP with Claude Code, Claude Desktop, or compatible tools.

MCP URL format:

https://mcp.apify.com/?tools=fetch_cat/shopify-products-scraper

Add it in Claude Code:

$claude mcp add apify-shopify-products "https://mcp.apify.com/?tools=fetch_cat/shopify-products-scraper"

Claude Desktop JSON configuration:

{
  "mcpServers": {
    "apify-shopify-products": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/shopify-products-scraper"
    }
  }
}

Example prompts:

• "Scrape 25 products from deathwishcoffee.com and summarize price ranges."
• "Compare vendors and product types from these three Shopify stores."
• "Find products with compare-at prices and list discount candidates."

Data quality notes

Prices are returned as numbers when present.

Currency is only filled when it can be inferred.

Availability is summarized from variant availability.

Product tags are normalized into an array.

Product URLs are built from the storefront domain and product handle.

Limits

The actor targets public Shopify storefront data.

It does not log in to stores.

It does not bypass hard security walls.

It does not guarantee that every Shopify store exposes a public catalog.

Very large catalogs may require higher maxProductsPerStore values and longer run time.

Legality

Only scrape public storefront data that you are allowed to process.

Respect applicable laws, website terms, and privacy obligations.

Do not use exported data for spam, deceptive practices, or prohibited profiling.

If you are unsure about your use case, consult your legal advisor.

Troubleshooting

Why did a store return an error row?

The store may not expose a public catalog, may block automated requests, or may not be a Shopify storefront.

Verify the domain in a browser and try a small run first.

Why are there fewer products than expected?

The store may have fewer public products than expected, hidden products, regional catalog differences, or storefront rules that limit catalog access.

Increase maxProductsPerStore only after confirming the store has more public products.

Why is currency empty?

Some public catalog responses provide prices without a currency code.

When currency cannot be inferred safely, the actor leaves it empty rather than guessing.

FAQ

Can I scrape multiple stores in one run?

Yes. Add multiple store URLs to storeUrls.

Can I export to CSV or Excel?

Yes. Use the Dataset tab in Apify Console to export results in common formats.

Does it include variants?

Yes, when includeVariants is enabled.

Does it include images?

Yes, when includeImages is enabled.

Does it need my Shopify API key?

No. The actor is designed for public storefront catalogs.

Related scrapers

Explore other ecommerce and product intelligence actors from fetch_cat on Apify:

• https://apify.com/fetch_cat/amazon-product-scraper
• https://apify.com/fetch_cat/etsy-scraper
• https://apify.com/fetch_cat/ebay-scraper

Support

If a public Shopify store fails unexpectedly, include the store URL and run ID when requesting support.

Small reproducible inputs are easiest to investigate.