# Shopify Product Scraper (`lightmoon/shopify-product-scraper`) Actor Export any Shopify store's full catalogue to CSV, Excel or JSON: variants, SKUs, prices, sale prices, stock and images. Opens stores that answer 403, 404 or 429 to other scrapers. From $0.79 per 1,000 products. No account, no API key. - **URL**: https://apify.com/lightmoon/shopify-product-scraper.md - **Developed by:** [Stable](https://apify.com/lightmoon) (community) - **Categories:** E-commerce, Lead generation, Developer tools - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $0.79 / 1,000 products 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/actors/running/actors-in-store.md#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 > **Unofficial.** This Actor is not affiliated with, endorsed by or sponsored by Shopify. It reads only publicly available pages, does not log in and does not bypass any access control. All product names and trademarks belong to their respective owners. ### Every product from any Shopify store — including the ones that refuse Paste store domains. Get their full catalogues as CSV, Excel or JSON: variants, SKUs, prices, sale prices, stock, images and the exact time each product last changed. No account, no API key, no browser. **About four Shopify stores in ten answer a scraper with 403, 404 or 429.** This one opens them anyway, and it does it without a proxy setting or anything for you to configure. Measured on 27 August 2026 over sixteen well-known stores: **fifteen opened. Four of those only through the second route — 94% against the 69% the ordinary route gives on its own.** #### One row, from a real run Taken from `mejuri.com` on 27 August. That store refused the ordinary route and came back through the second one — `resolvedVia` says which. Trimmed only in the variant list, from 26 down to one. ```json { "recordType": "product", "storeDomain": "mejuri.com", "storeHandle": "mejuri-us", "resolvedVia": "origin-host", "productId": 10385306419384, "title": "Interconnected Initial Pavé Diamond Charm", "handle": "interconnected-diamond-letter-charm", "productUrl": "https://mejuri.com/products/interconnected-diamond-letter-charm", "vendor": "Mejuri", "productType": "Charm", "tags": ["Interconnected: 14k Pave", "promo eligible"], "publishedAt": "2026-08-24T00:19:19-04:00", "createdAt": "2026-04-28T10:19:59-04:00", "updatedAt": "2026-08-27T04:07:51-04:00", "priceMin": 248, "priceMax": 248, "onSale": false, "available": true, "variantsTotal": 26, "variantsAvailable": 23, "variants": [ { "variantId": 53415571783864, "title": "14k Yellow Gold / Lab Grown Diamond / D", "sku": "p538750114", "price": 248, "compareAtPrice": null, "onSale": false, "available": true, "grams": 1, "options": ["14k Yellow Gold", "Lab Grown Diamond", "D"] } ], "options": [ { "name": "Material", "values": ["14k Yellow Gold"] }, { "name": "Stone", "values": ["Lab Grown Diamond"] }, { "name": "Letter", "values": ["A", "B", "C", "D", "E", "F", "G"] } ], "imageCount": 4, "featuredImage": "https://cdn.shopify.com/s/files/1/0631/8568/2616/files/0_Interconnected_Diamond.jpg", "scrapedAt": "2026-08-27T12:07:44Z" } ``` ### Fields **27 per product. 9 more on every variant.** Counted, not estimated — the list below is the whole of it. | | | |---|---| | where it came from | `recordType`, `storeDomain`, `storeHandle`, `resolvedVia` | | the product | `productId`, `title`, `handle`, `productUrl`, `vendor`, `productType`, `tags`, `description` | | dates | `publishedAt`, `createdAt`, `updatedAt` | | money | `priceMin`, `priceMax`, `onSale` | | stock | `available`, `variantsTotal`, `variantsAvailable` | | every variant | `variants` — **`variantId`, `title`, `sku`, `price`, `compareAtPrice`, `onSale`, `available`, `grams`, `options`** | | options | `options` — each option name with all of its values | | pictures | `imageCount`, `featuredImage`, `images` | | when it was read | `scrapedAt` | Every row names its own store, so a run over fifty domains needs no join. #### And one status row per store ```json { "recordType": "store", "storeDomain": "bombas.com", "storeHandle": null, "resolvedVia": null, "status": "refused", "detail": "bombas.com refused the catalogue and its own home page", "currency": null, "productsReturned": 0, "pagesFetched": 0 } ``` A store that could not be read is **named**, with the reason. It is never silently missing from the output, and it is never charged for. ### Why some stores refuse, and what happens then Shopify publishes a store's catalogue at a documented address on the store's own domain. Plenty of shops close that address — the answer is 403, 404 or 429 — and for most tools that is the end of the story. Every Shopify shop also has a second, internal address, and it is usually still open. The catch is that it is not the brand name: `gymshark.com` lives at `gymsharkusa`, `hiutdenim.co.uk` at `hiut`, `mejuri.com` at `mejuri-us`. Four of six are not guessable at all. This actor reads the store's own front page, finds the internal name there, and fetches the catalogue from it. That costs one extra request, and only for the stores that needed it — `resolvedVia` tells you which ones those were. The order is cheapest-first, so a store that answers normally costs one request: 1. the catalogue on the store's own domain 2. a second catalogue path on the same domain 3. the front page, to read the internal name 4. the catalogue on the internal address ### Filters Applied before a row is stored, so **a product removed by a filter is never charged for**. | | | |---|---| | `onlyAvailable` | in stock only | | `onlyOnSale` | only products marked down | | `minPrice`, `maxPrice` | a price band | | `productTypes`, `vendors` | by type or brand | | `titleContains` | a word in the title | | `updatedSince` | **only what changed since a date** | | `includeVariants`, `includeImages`, `includeDescription` | leave out what you do not need | `updatedSince` is the one that pays for itself. Give it the date of your last run and a daily check of a shop that changes twenty products costs twenty rows, not the whole catalogue. ### What it costs Pay per event, and there is one paid event: **a stored product**. | | GOLD per 1,000 | |---|---| | **Product** | **$0.79** | The status rows are free. Filtered-out products are free. A store that could not be read is free. - A 250-product catalogue: **$0.20**. - A 2,400-product catalogue: **$1.90**. - Apify's $5 of monthly free credit: about **5,000 products**. A single store's catalogue takes one or two requests and finishes in under twenty seconds. Five stores at once, one of them needing the second route, took 23 seconds in testing. ### Limits Stated plainly, because these are properties of what Shopify shows the public and no scraper talks them away. - **Some stores stay shut.** The second route opens most refusals, not all. One of sixteen stayed closed in testing, and it is named in the output. - **Refusals move.** A shop that answers today may refuse next week, and the reverse — several stores that were closed nine days earlier were open again on the day of the last measurement. - **Public catalogue only.** No customers, no orders, no traffic, no revenue. - **A site that is not on Shopify returns nothing** and says so, rather than pretending the catalogue is empty. - **On the free plan** everything works at the FREE rate until Apify's monthly platform credit runs out; the run then stops cleanly and keeps what it has. # Actor input Schema ## `storeDomains` (type: `array`): One per line, in any form: `allbirds.com`, `https://www.allbirds.com/`, a link to a single product, or the internal address `example.myshopify.com`. Duplicates and `www.` variants of the same shop are merged, so pasting a messy list costs you one run per store and not one per line. ## `maxProducts` (type: `integer`): Across all stores. 0 means no limit. A catalogue page carries up to 250 products, so a store of 300 costs two requests — start small on the free plan, where your own Apify usage is the cap. ## `maxProductsPerStore` (type: `integer`): How deep to read one store before moving to the next. 0 means no limit. Use it to sample forty competitors evenly instead of spending the whole run inside the first one. ## `onlyAvailable` (type: `boolean`): Keep products with at least one variant in stock. **Filters run before billing**, so what a filter removes is never charged to you — you pay for the products you asked for and we pay for the rest of the page. ## `onlyOnSale` (type: `boolean`): Keep products where at least one variant has a compare-at price above its current price. This is the field a raw catalogue download makes you compute yourself. ## `minPrice` (type: `integer`): In the store's own currency. A product is kept if any of its variants reaches this price, so a 45–95 product belongs to both `over 90` and `under 50`. ## `maxPrice` (type: `integer`): In the store's own currency. Combine with the field above to take one price band out of a catalogue. ## `productTypes` (type: `array`): Shopify's own `product_type` field, matched exactly but ignoring case — for example `Shoes`, `T-Shirts`. Leave empty for every type. Run once without it to see what a store actually uses; the values are the store owner's, not a standard list. ## `vendors` (type: `array`): Shopify's `vendor` field, matched exactly but ignoring case. On a multi-brand store this is how you take one brand out of it. ## `titleContains` (type: `string`): A word or phrase, matched anywhere in the product title, ignoring case. ## `updatedSince` (type: `string`): Keep only products the store has added or edited since then. Either a date — `2026-08-01` — or a span relative to the run: `24h`, `7d`, `2w`. **The relative form is what makes a schedule work**: a daily task set to `24h` returns what changed yesterday, every day, without anyone editing it. ## `includeVariants` (type: `boolean`): Every size, colour and SKU with its own price, sale price and stock flag. This is the largest part of a row — turning it off keeps `variantsTotal`, `variantsAvailable`, `priceMin` and `priceMax`, and makes the export several times smaller for a spreadsheet. ## `includeImages` (type: `boolean`): The full image list in the store's own order. Turning it off keeps `imageCount` and `featuredImage`. ## `includeDescription` (type: `boolean`): The product description as plain readable text rather than as raw HTML. ## Actor input object example ```json { "storeDomains": [ "allbirds.com" ], "maxProducts": 1000, "maxProductsPerStore": 5000, "onlyAvailable": false, "onlyOnSale": false, "productTypes": [ "Shoes" ], "vendors": [ "Allbirds" ], "titleContains": "runner", "updatedSince": "7d", "includeVariants": true, "includeImages": true, "includeDescription": true } ``` # Actor output Schema ## `products` (type: `string`): No description ## `pricing` (type: `string`): No description ## `catalogue` (type: `string`): No description ## `images` (type: `string`): No description ## `stores` (type: `string`): No description ## `all` (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 = { "storeDomains": [ "allbirds.com", "gymshark.com" ] }; // Run the Actor and wait for it to finish const run = await client.actor("lightmoon/shopify-product-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 = { "storeDomains": [ "allbirds.com", "gymshark.com", ] } # Run the Actor and wait for it to finish run = client.actor("lightmoon/shopify-product-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 '{ "storeDomains": [ "allbirds.com", "gymshark.com" ] }' | apify call lightmoon/shopify-product-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,lightmoon/shopify-product-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/PyKrg2pSeuuV4wOxI/builds/UB7Dh1r0rF86XGh4P/openapi.json