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
resultevent for each successful saved product row. - Login required: No. The Actor reads public Shopify storefront catalog data only.
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
includeVariantsis enabled. - Image URLs and dimensions when
includeImagesis enabled. - Clear per-store failure details in
RUN_SUMMARYfor 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.
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.
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 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.
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.
