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.

At a glance

• Input: Shopify storefront URLs, per-store product cap, variant mode, image mode, raw product mode, and optional proxy settings.
• Output: One dataset row per public product with title, handle, URL, vendor, product type, tags, price range, availability, variants, images, and status fields.
• Best for: Product catalog exports, price monitoring, assortment research, merchandising audits, and ecommerce data pipelines.
• Pricing unit: A start event per run plus one result event for each successful saved product row.
• Login required: No. The Actor reads public Shopify storefront catalog data only.

Ready-to-run examples

Start with a published example task or copy the same idea into your own run:

• Shopify Coffee Store Products: export a small public storefront catalog.
• Shopify Competitor Product Catalogs: compare multiple public stores.
• Shopify Product Image Dataset: include product image URLs for visual workflows.
• Shopify Product Variants, Prices & Availability: include variant rows and availability fields.

What can it 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	Preserve a per-store failure summary and a resumable store list when a public catalog cannot be read.

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 per-store failure details in RUN_SUMMARY for stores that do not expose a public catalog.
• Scheduling, API, and integration support for recurring workflows.

Common workflows

• 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 configuration

The main input is storeUrls. Enter storefront homepages or domains such as https://www.deathwishcoffee.com; the Actor normalizes each value to a storefront origin before scraping.

Setting	JSON key	Use it for	Example
Store URLs	storeUrls	Shopify storefront homepages or domains to scrape.	[{"url":"https://www.deathwishcoffee.com"}]
Maximum products per store	maxProductsPerStore	Cap saved product rows per storefront.	25
Maximum run time	maxRunSeconds	Stop cleanly before the platform timeout and save unfinished stores for a later run.	270
Resume store URLs	resumeStoreUrls	Continue with URLs saved in PENDING_STORE_URLS after a partial run.	["https://example-store.com"]
Include variants	includeVariants	Add variant-level SKU, price, compare-at price, availability, and options.	true
Include images	includeImages	Add product image URLs and dimensions.	true
Include raw product JSON	includeRawProduct	Attach the original Shopify product payload for advanced processing.	false
Proxy configuration	proxyConfiguration	Residential Apify Proxy is enabled by default to avoid storefront rate limits. It can incur separate proxy-traffic charges; disable it only for a storefront you control or have tested directly.	{"useApifyProxy":true,"apifyProxyGroups":["RESIDENTIAL"]}

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.

Successful product rows have status set to success.

If a store cannot be read, inspect the run's RUN_SUMMARY key-value record. It contains the per-store failure reason; PENDING_STORE_URLS is written when the run ends before all stores are attempted and can be supplied as resumeStoreUrls in a follow-up run.

Output example

{
  "status": "success",
  "storeUrl": "https://www.deathwishcoffee.com",
  "storeDomain": "www.deathwishcoffee.com",
  "productId": 1234567890,
  "title": "Sample Coffee",
  "handle": "sample-coffee",
  "url": "https://www.deathwishcoffee.com/products/sample-coffee",
  "vendor": "Death Wish Coffee",
  "priceMin": 19.99,
  "priceMax": 24.99,
  "available": true,
  "variantCount": 2,
  "imageCount": 4,
  "sourceUrl": "https://www.deathwishcoffee.com/products.json?limit=250&page=1",
  "scrapedAt": "2026-07-17T00:00:00.000Z"
}

When a store cannot be read, the dataset contains an error row with status: "error", storeUrl, sourceUrl, and errorMessage so multi-store runs can finish without hiding the failed storefront.

Output fields

Field	Description
status	success for saved product rows or error for a store-level failure row.
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.
rawProduct	Optional original product object.
errorMessage	Failure reason for rows with status set to error.

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.

Tier	start per run	result per successful product
Free	$0.005	$0.000028124
Bronze	$0.005	$0.000024456
Silver	$0.005	$0.000019075
Gold	$0.005	$0.000014673
Platinum	$0.005	$0.000010000
Diamond	$0.005	$0.000010000

Apify may also charge platform usage for compute, storage, proxy traffic, or data transfer outside this Actor pricing. Residential Apify Proxy is enabled by default for reliability, so 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.

For API automation, see the Node.js, Python, and cURL examples below.

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 RUN_SUMMARY 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 records those stores in RUN_SUMMARY instead of hiding failures or charging a result event.

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 examples

Use Node.js, Python, or cURL to start runs from your own workflows.

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);

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'])

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 and AI agents

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 these details when requesting support:

• Input JSON: the exact storeUrls, limits, and options used for the run.
• Expected output: the products or fields you expected to receive.
• Actual output: the dataset row, RUN_SUMMARY, or error message you received.
• Reproducible public URL: a storefront URL that can be tested without logging in.
• Run ID: the Apify run ID or run link.

Small reproducible inputs are easiest to investigate.

Privacy and data handling

This Actor only requests the permissions needed to run the input you provide. It uses your input (such as URLs, search terms, identifiers, filters, and limits) only to fetch the requested public data from the relevant source site or API for this Actor, then writes results to your Apify dataset/key-value store.

Data may pass through Apify platform services and Apify Proxy during the run, and requests are sent only to the target site or public data provider required for this Actor's results. FetchCat does not send your inputs or outputs to advertising networks, data brokers, or model-training services, and does not retain run data outside Apify storage after the run except when you explicitly share run details for transient support debugging.

You are responsible for using this Actor lawfully, respecting the target site's terms, and avoiding unnecessary personal or sensitive data in inputs. Review the output before storing, sharing, or combining it with other data.