# Shopify Products Scraper (`parsebird/shopify-products-scraper`) Actor Scrape the full public product catalog of any Shopify store. Extract titles, prices, sale status, stock flags, variants, options, images, tags, vendor, product type, and timestamps. Export as JSON, CSV, Excel. - **URL**: https://apify.com/parsebird/shopify-products-scraper.md - **Developed by:** [ParseBird](https://apify.com/parsebird) (community) - **Categories:** E-commerce, Lead generation, Automation - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks - **User rating**: No ratings yet ## Pricing from $0.79 / 1,000 product scrapeds This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have. Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event ## What's an Apify Actor? Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Actors are written with capital "A". ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. The best way to integrate Actors is as follows. - **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use). - **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`. - **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`. - **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`. - **Any other language** — the [REST API](https://docs.apify.com/api/v2.md). For usage examples, see the [API](#api) section below. For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt). # README ### Shopify Products Scraper Scrape the full public product catalog of any Shopify store — prices, sale status, stock flags, variants, options, images, tags, vendor, and timestamps — from one or more store domains.
Paste any Shopify domain and get one clean row per product with 28 fields — price range, compare-at price, on-sale and out-of-stock flags, variant count, option names, product type, tags, and plain-text descriptions — across unlimited stores in a single run.

ParseBird Shopify Suite   •  Store discovery, lead enrichment, and product catalog tools
 Shopify Store Leads Scraper
Discover stores by keyword 		 Shopify Store B2B Leads Finder
Enrich domains into leads 		 Shopify Products Scraper
➤ You are here
##### Copy to your AI assistant Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor. ``` Shopify Products Scraper (parsebird/shopify-products-scraper) extracts the full public product catalog of any Shopify store. Call via ApifyClient: client.actor("parsebird/shopify-products-scraper").call(run_input={"domains": ["gymshark.com", "deathwishcoffee.com"], "maxProducts": 500}). Inputs: domains (array of strings, required — bare hostnames like "gymshark.com", full URLs, or "store.myshopify.com" subdomains; up to 100 per run), maxProducts (int, default 0 = entire catalog, per store), proxyConfiguration (object, default {"useApifyProxy": false} — enable Apify Proxy RESIDENTIAL only if a domain returns HTTP 403), datasetId (string, optional — append rows to an existing Apify dataset as well), runId (string, optional — copied into every row for pipeline traceability). Output fields per product: store, productId, handle, title, vendor, url, featuredImage, imageCount, imageAltTexts, currency, priceMin, priceMax, compareAtPrice, onSale, available, fullyOutOfStock, requiresShipping, variantCount, options, weightAndUnit, productType, tags, description, publishedAt, updatedAt, createdAt, runId, scrapedAt. Pricing is pay-per-event: $0.99/1,000 products (Free), $0.95 (Bronze), $0.89 (Silver), $0.79 (Gold). Get API token: https://console.apify.com/account#/integrations ``` ### What does Shopify Products Scraper do? Shopify Products Scraper reads the public storefront product feed that every [Shopify](https://www.shopify.com) store publishes and turns it into a flat, analysis-ready table. Give it a list of store domains and it walks each catalog page by page, returning **one structured row per product** — no store login, no API key, and no partner account required. It is the practical **Shopify API alternative** when you need competitor catalogs rather than your own. - 🏬 **Any Shopify store, any domain format** — Bare hostnames (`gymshark.com`), full URLs (`https://allbirds.com/collections/mens`), and `.myshopify.com` subdomains all work. Up to 100 stores per run. - 💵 **Full pricing picture** — Lowest and highest variant price, the highest compare-at price, and a computed `onSale` flag that only fires on a genuine discount. - 📦 **Stock signals** — `available` when any variant is buyable, `fullyOutOfStock` when the whole product is sold out, plus `requiresShipping` to separate physical goods from digital ones. - 🎨 **Variants and options** — Variant count and the option names shoppers actually pick from (Size, Color, Flavor), with Shopify's placeholder single-variant option filtered out. - 🏷️ **Merchandising metadata** — Vendor, merchant product type, full tag list, and the plain-text description with all HTML stripped. - 🖼️ **Images** — Featured image URL and total image count for every product. - 🕒 **Freshness timestamps** — `publishedAt`, `updatedAt`, and `createdAt`, so you can spot new arrivals and recently repriced items. - 🔁 **Pipeline-ready** — Optionally mirror every row into a second Apify dataset and stamp each row with your own `runId` for traceability. - 🌍 **Automatic host recovery** — Some storefronts serve the feed on only one host variant. The scraper transparently retries the `www`/non-`www` counterpart, so `www.gymshark.com` still works even though that exact host returns HTTP 403. ### What data can you extract from Shopify stores? | Field | Type | Description | |-------|------|-------------| | **store** | string | Domain the product was scraped from | | **productId** | number | Shopify's internal product ID | | **handle** | string | URL slug of the product | | **title** | string | Product title | | **vendor** | string | Merchant-assigned brand or vendor | | **url** | string | Full product page URL | | **featuredImage** | string | URL of the first product image | | **imageCount** | number | Number of images on the product | | **imageAltTexts** | array | Non-empty image alt texts, when the storefront publishes them | | **currency** | string | ISO 4217 shop currency (for example `USD`, `GBP`) | | **priceMin** | number | Lowest variant price | | **priceMax** | number | Highest variant price | | **compareAtPrice** | number | Highest compare-at price, or `null` when none is set | | **onSale** | boolean | `true` when any variant's compare-at price exceeds its selling price | | **available** | boolean | `true` when at least one variant is in stock | | **fullyOutOfStock** | boolean | `true` when every variant is sold out | | **requiresShipping** | boolean | `true` when the product needs physical shipping | | **variantCount** | number | Number of variants | | **options** | array | Option names shoppers choose from (Size, Color) | | **weightAndUnit** | string | First-variant weight in grams, or `null` when unset | | **productType** | string | Merchant-assigned product type | | **tags** | array | Shopify tags on the product | | **description** | string | Product description with HTML stripped | | **publishedAt** | string | ISO timestamp the product went live | | **updatedAt** | string | ISO timestamp of the last product update | | **createdAt** | string | ISO timestamp the product was created | | **runId** | string | Parent run ID copied from input, or `null` | | **scrapedAt** | string | ISO timestamp of this scrape | ### Input parameters | Parameter | Type | Required | Default | Description | |-----------|------|----------|---------|-------------| | domains | array | **Yes** | — | Shopify store domains. Bare hostnames, full URLs, and `.myshopify.com` subdomains all work. Max 100 per run | | maxProducts | integer | No | 0 | Maximum products **per store**. `0` scrapes the entire catalog | | proxyConfiguration | object | No | `{"useApifyProxy": false}` | Proxy settings. Enable Apify Proxy Residential only when a domain returns HTTP 403 | | datasetId | string | No | — | Existing Apify dataset ID to append rows to, alongside the default dataset | | runId | string | No | — | Identifier copied into every output row for pipeline traceability | Input example: ```json { "domains": ["gymshark.com", "deathwishcoffee.com"], "maxProducts": 500, "proxyConfiguration": { "useApifyProxy": false } } ``` ### How to scrape Shopify products 1. **Open the Actor** — Go to [Shopify Products Scraper](https://apify.com/parsebird/shopify-products-scraper) in Apify Console and click **Try for free**. 2. **Add store domains** — Enter one domain per row, for example `gymshark.com` and `deathwishcoffee.com`. Paste a full product or collection URL and the scraper reduces it to the hostname for you. 3. **Set a product limit** — Leave **Max products per store** at `0` to pull the whole catalog, or set a small number like `50` for a quick, cheap test run. 4. **Leave Advanced alone** — Proxies are off by default and most storefronts do not need them. Only enable Apify Proxy (Residential) if a domain returns HTTP 403. 5. **Click Start** — The scraper resolves each domain, detects the shop currency, and paginates the catalog in batches of 250 products. 6. **Download your data** — Export as **JSON, CSV, Excel, XML, or HTML** from the Storage tab, or pull it through the [Apify API](https://docs.apify.com/api/v2). ### Output example ```json { "store": "deathwishcoffee.com", "productId": 7308479168567, "handle": "maple-cinnamon-tee", "title": "Maple Cinnamon Tee", "vendor": "Planet Apparel", "url": "https://deathwishcoffee.com/products/maple-cinnamon-tee", "featuredImage": "https://cdn.shopify.com/s/files/1/0271/7209/files/DeathWishCoffee_MapleCinnamonTee_Front_Web2.jpg", "imageCount": 5, "imageAltTexts": [], "currency": "USD", "priceMin": 15.0, "priceMax": 15.0, "compareAtPrice": 30.0, "onSale": true, "available": true, "fullyOutOfStock": false, "requiresShipping": true, "variantCount": 6, "options": ["Size"], "weightAndUnit": "161 g", "productType": "Apparel", "tags": ["Apparel", "Men", "Merch", "Sale", "Unisex", "Women"], "description": "Deceptively sweet. Dangerously bold.", "publishedAt": "2025-09-26T10:02:23-04:00", "updatedAt": "2026-08-05T08:20:41-04:00", "createdAt": "2025-09-26T09:41:20-04:00", "runId": "qa-run", "scrapedAt": "2026-08-05T12:22:58.991053+00:00" } ``` Download results in **JSON, CSV, Excel, XML, or HTML** directly from the [Apify dataset](https://docs.apify.com/platform/storage/dataset). ### Use cases **Competitor price monitoring** — Schedule a daily run across your competitors' domains and track `priceMin`, `compareAtPrice`, and `onSale` over time to detect price changes and promotions the day they launch. **Assortment and gap analysis** — Compare `productType`, `tags`, and `vendor` distributions across several stores to find categories your competitors cover and you do not. **Stock and availability tracking** — Watch `fullyOutOfStock` and `available` to see what is selling out at rival stores, and time your own inventory or campaigns around it. **Dropshipping and reselling research** — Pull entire supplier catalogs with prices, variants, weights, and images to evaluate margins before committing to a product line. **Product feed building** — Turn any Shopify catalog into a clean feed for affiliate sites, comparison shopping engines, or marketplace listings. **AI and search datasets** — Use titles, plain-text descriptions, tags, and images as training or retrieval data for product classifiers, recommenders, and semantic search. ### How it works 1. **Domain normalization** — Every input is reduced to a bare hostname: schemes, credentials, ports, paths, and query strings are stripped, and internationalized domains are converted to punycode. 2. **Host resolution** — The scraper probes the storefront product feed and, if that host does not answer with product JSON, transparently retries the `www`/non-`www` counterpart before giving up. 3. **Currency detection** — The shop's ISO 4217 currency is read once per store from its public storefront metadata and applied to every row. 4. **Pagination** — Products are fetched in batches of 250 and the scraper stops as soon as a short page signals the end of the catalog or your `maxProducts` limit is reached. 5. **Normalization** — Each product is flattened into one row: prices are converted from strings to numbers, HTML is stripped from descriptions, placeholder single-variant options are removed, and sale detection ignores compare-at prices that are zero or not above the selling price. 6. **Delivery** — Rows are pushed to the run's dataset (and optionally a second dataset) as they are scraped, so partial results are available even if a run is aborted. Non-Shopify sites are detected and skipped with a clear log message rather than failing the whole run. ### How much does it cost to scrape Shopify products? Shopify Products Scraper uses **pay-per-event** pricing — you pay for products delivered, not for compute time. | Plan | Price per product | Price per 1,000 products | |------|------------------:|-------------------------:| | Free | $0.00099 | **$0.99** | | Bronze | $0.00095 | **$0.95** | | Silver | $0.00089 | **$0.89** | | Gold | $0.00079 | **$0.79** | One event is charged per product row pushed to the dataset. **Example:** scraping a 5,000-product catalog costs **$4.95** on the Free plan and **$3.95** on Gold. A 250-product test run costs about **$0.25**. New users get a [free trial](https://apify.com/pricing) with platform credits, which is enough to scrape several thousand products before paying anything. See the [Pricing tab](https://apify.com/parsebird/shopify-products-scraper) for current rates. ### Programmatic API usage #### Python ```python from apify_client import ApifyClient client = ApifyClient("") run_input = { "domains": ["gymshark.com", "deathwishcoffee.com"], "maxProducts": 500, "proxyConfiguration": {"useApifyProxy": False}, } run = client.actor("parsebird/shopify-products-scraper").call(run_input=run_input) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): flag = "SALE" if item["onSale"] else " " stock = "in stock" if item["available"] else "sold out" print(f"{flag} {item['store']:24s} {item['title'][:40]:42s} " f"{item['priceMin']} {item['currency']} ({stock})") ``` #### JavaScript ```javascript import { ApifyClient } from "apify-client"; const client = new ApifyClient({ token: "" }); const input = { domains: ["gymshark.com", "deathwishcoffee.com"], maxProducts: 500, proxyConfiguration: { useApifyProxy: false }, }; const run = await client.actor("parsebird/shopify-products-scraper").call(input); const { items } = await client.dataset(run.defaultDatasetId).listItems(); items .filter((item) => item.onSale) .forEach((item) => { console.log(`${item.title} — ${item.priceMin} ${item.currency} (was ${item.compareAtPrice})`); }); ``` Get your API token at [Apify Console → Integrations](https://console.apify.com/account#/integrations), and see the [Apify API reference](https://docs.apify.com/api/v2) for the full endpoint list. Use [Apify scheduling](https://docs.apify.com/platform/schedules) to run daily, weekly, or at any interval, and connect [integrations](https://apify.com/integrations) to push results straight into Google Sheets, Slack, Zapier, Make, webhooks, or your own database. ### Is it legal to scrape Shopify product data? Shopify Products Scraper only reads **publicly available product data** that stores choose to publish on their own storefronts — the same catalog information any visitor can see by browsing the shop. It does not log in, bypass authentication, use a merchant's private admin API, or collect personal data about customers or store owners. Scraping public data is generally lawful in the US and EU, but the way you use it still matters. Product titles, descriptions, and images may be protected by copyright, so republishing them verbatim is a separate question from collecting them. Review [Shopify's terms of service](https://www.shopify.com/legal/terms) and your own legal obligations before redistributing scraped content, and see [Apify's guide on the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/) for more background. ### Related Actors More ParseBird data extraction tools on the [Apify Store](https://apify.com/parsebird): - [Shopify Store Leads Scraper](https://apify.com/parsebird/shopify-store-leads-scraper) — Find Shopify stores by keyword or category and extract emails, phones, addresses, and social links. Pair it with this actor to discover stores first, then scrape their catalogs. - [eBay Sold Listings Scraper](https://apify.com/parsebird/ebay-sold-listings-scraper) — Extract sold prices and sales history for pricing research - [Trendyol Product Scraper](https://apify.com/parsebird/trendyol-product-scraper) — Scrape products, prices, and ratings from Trendyol - [Product Hunt Scraper](https://apify.com/parsebird/product-hunt-scraper) — Extract Product Hunt launches, leaderboards, and maker data - [Data Deduplicator](https://apify.com/parsebird/dataset-deduplicator) — Remove duplicate rows from any Apify dataset - [Data Cleaner](https://apify.com/parsebird/data-cleaner) — Normalize and clean scraped datasets before analysis ### FAQ **Do I need a Shopify API key or partner account?** No. The scraper reads the public storefront catalog that Shopify stores publish by default. There is nothing to authenticate and no app to install. **How do I know whether a store runs on Shopify?** Run it and check the log. If a domain is not a Shopify storefront, the scraper reports it clearly and moves on to the next domain instead of failing the run. Sites that are not Shopify are the most common reason for an empty result. **How many stores and products can I scrape in one run?** Up to 100 domains per run, and up to 100,000 products per store. Set `maxProducts` to cap each store, or leave it at `0` for the full catalog. **A domain returns HTTP 403. What should I do?** Enable Apify Proxy with the Residential group in the Advanced section and run it again. Proxies are off by default because most storefronts do not need them, and running without one is faster. **Why did `www.example.com` work when I entered `example.com` (or the other way round)?** Some storefronts serve the product feed on only one of the two hosts. The scraper detects this and automatically retries the counterpart, so either form works. The `store` field records the host that actually answered. **Why is `imageAltTexts` usually empty?** Most current Shopify themes do not include image alt text in the public product feed, so the array is empty for the majority of stores. The field is populated whenever a storefront does publish alt text. Use `featuredImage` and `imageCount` for reliable image data. **Why is `weightAndUnit` null for some stores?** Shopify reports variant weight in grams, and many merchants leave it at zero — especially for apparel and digital products. The field is `null` in that case rather than a misleading `0 g`. **Does `onSale` just mean a compare-at price exists?** No. Many stores set the compare-at price equal to the selling price, or to `0.00`, neither of which is a discount. `onSale` is `true` only when a variant's compare-at price is strictly higher than what it actually sells for. **Is the data live?** Yes. Every run fetches current catalog data. Nothing is cached or pre-scraped, so prices and stock flags reflect the store at the moment of the run. **How do I track price changes over time?** Schedule the actor to run daily with [Apify schedules](https://docs.apify.com/platform/schedules) and keep appending to the same dataset with the `datasetId` input. Set `runId` to tag each batch, then compare `priceMin` and `onSale` per `productId` across runs. **Can I export the data?** Yes. Download as JSON, CSV, Excel, XML, or HTML from Apify Console, fetch it through the [Apify API](https://docs.apify.com/api/v2), or push it automatically to [Google Sheets, Slack, Zapier, Make, or Airbyte](https://apify.com/integrations). **Something looks wrong or a store fails — where do I report it?** Open a report on the actor's **Issues** tab in Apify Console. Include the domain you tried and the log output; feedback and feature requests are welcome. # Actor input Schema ## `domains` (type: `array`): Add one domain per row. Bare hostnames (gymshark.com), full URLs (https://allbirds.com/collections/mens), and .myshopify.com subdomains all work — everything after the hostname is ignored.

Not every online shop runs on Shopify. If a domain returns no products, it is most likely not a Shopify store. ## `maxProducts` (type: `integer`): Stop after this many products from each store. Set to 0 to scrape the entire catalog. ## `proxyConfiguration` (type: `object`): Most Shopify storefronts respond fine without a proxy, so this is off by default. Turn on Apify Proxy with the Residential group only if a store returns HTTP 403. ## `datasetId` (type: `string`): Append every product row to an existing Apify dataset as well as this run's default dataset. Leave empty to use the default dataset only. ## `runId` (type: `string`): Copy an identifier of your choice into the runId field of every output row, so downstream jobs can trace which pipeline run produced them. ## Actor input object example ```json { "domains": [ "deathwishcoffee.com" ], "maxProducts": 50, "proxyConfiguration": { "useApifyProxy": false } } ``` # Actor output Schema ## `dataset` (type: `string`): No description # API You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup. ## JavaScript example ```javascript import { ApifyClient } from 'apify-client'; // Initialize the ApifyClient with your Apify API token // Replace the '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "domains": [ "deathwishcoffee.com" ], "maxProducts": 50 }; // Run the Actor and wait for it to finish const run = await client.actor("parsebird/shopify-products-scraper").call(input); // Fetch and print Actor results from the run's dataset (if any) console.log('Results from dataset'); console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`); const { items } = await client.dataset(run.defaultDatasetId).listItems(); items.forEach((item) => { console.dir(item); }); // 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs ``` ## Python example ```python from apify_client import ApifyClient # Initialize the ApifyClient with your Apify API token # Replace '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "domains": ["deathwishcoffee.com"], "maxProducts": 50, } # Run the Actor and wait for it to finish run = client.actor("parsebird/shopify-products-scraper").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}") for item in client.dataset(run.default_dataset_id).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "domains": [ "deathwishcoffee.com" ], "maxProducts": 50 }' | apify call parsebird/shopify-products-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,parsebird/shopify-products-scraper" } } } ``` The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer ` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations). ## OpenAPI specification Download the OpenAPI definition: https://api.apify.com/v2/actors/SM0wdI7pKS4vmNOrz/builds/ScbwNlnr9KQg8cuQT/openapi.json