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 Shopify storefront catalogs into clean product datasets for price monitoring, catalog QA, and product intelligence.

Capability	What it does
Scrape public catalogs	Accept Shopify store homepages or domains and save one row per product.
Run one or many stores	Test one brand or collect catalogs across multiple storefronts.
Export product data	Save titles, handles, vendors, product types, tags, prices, availability, and product URLs.
Include rich fields	Optionally include variants, image records, and the raw product payload.
Handle failures	Save error rows when a store does not expose a readable public catalog.

Who is it for?

Team	Use case
Ecommerce analysts	Compare product catalogs across brands.
Agencies	Build market and assortment reports for clients.
Brand operators	Audit pricing, variants, images, tags, and availability.
Automation teams	Feed product data into workflows, alerts, and databases.
Researchers	Create structured product datasets without manual copying.

Why use this actor?

• Simple input: enter storefront domains and get product rows.
• Multi-store runs for comparing brands, categories, or markets.
• Variant-level prices and availability when includeVariants is enabled.
• Image URLs and dimensions when includeImages is enabled.
• Clear error rows for stores that do not expose a public catalog.
• Scheduling, API, and integration support for recurring workflows.

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.

Pricing

This Actor uses Apify pay-per-event pricing. The prices below come from the current Actor pricing configuration. Apify public plans map to Store discount tiers, so the table shows both the user-facing plan context and the pricing tier name. The final price shown in Apify depends on the user account plan and any custom agreement.

Event	What is charged	Price
start	One-time fee per run	$0.005
result	Per Shopify product record produced	$0.000024

Apify may also charge platform usage for compute, storage, proxies, or data transfer outside this Actor pricing. Check the Actor run and the Apify Pricing tab for the exact cost shown to your account.

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:

• Google Shopping Results Scraper
• AliExpress Products Scraper
• Walmart Products Scraper
• Shopify App Reviews Scraper
• Website Contact Finder

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.