Shopify Products Scraper

Shopify Products Scraper is an Apify Actor for Shopify storefronts. It accepts store domains or homepage URLs, collection page URLs, or individual product URLs, and returns one dataset record per product. Each record can include product ID, title, handle, canonical URL, store domain, vendor, product type, description, tags, currency, pricing, availability, variant counts, image counts, option data, featured image, images, variants, and timestamps. The Actor is usable through Apify MCP, the Apify API, and standard Apify runs.

Best fit and connected workflows

Use this Actor when your source is already a Shopify URL and you want the scrape scope to match the input type:

• Store URLs for a full catalog export from one or more Shopify stores.
• Collection URLs for a category-level scrape from a Shopify collection page.
• Product URLs for a focused shortlist of known product pages.
• Include variants when you want per-variant pricing, SKU, availability, and options in each record.
• Include images when downstream tools need the full image URL list alongside the featured image.
• Send the dataset to catalog normalization, pricing review, product monitoring, and AI agent workflows.

This Actor is designed as a focused standalone workflow.

Practical scenario

A merchandiser receives a Shopify collection page for running shoes and wants a current assortment snapshot. She enters the collection URL, keeps variants enabled, and sets a product cap for the run. The Actor returns one record per product with fields such as title, price, compare-at price, availability, option names, and featured image. She reviews the price and product type fields, then sends the dataset into a weekly assortment report.

Input

Field	Type	Description
storeUrls	array	Store domains or homepage URLs for scraping the entire catalog through /products.json, paginated until all products are collected. Add many to batch multiple stores in one run.
collectionUrls	array	Collection page URLs for scraping only products in that collection through /collections/<handle>/products.json.
productUrls	array	Individual product page URLs for one detailed record per product through the product .json endpoint.
maxProducts	integer	Total cap on products scraped across the run. Defaults to 1000. Billing stops at this number.
includeVariants	boolean	Includes a variants array with per-variant price, SKU, availability, and options. Defaults to true.
includeImages	boolean	Includes an images array with image URLs. A featuredImage field is always present. Defaults to true.
proxyConfiguration	object	Apify Proxy settings for requests. The default uses Apify Proxy (auto).

Focused JSON example

{
  "storeUrls": [
    "gymshark.com"
  ],
  "collectionUrls": [
    "https://www.allbirds.com/collections/mens"
  ],
  "productUrls": [
    "https://your-store.com/products/product-handle"
  ],
  "maxProducts": 500,
  "includeVariants": true,
  "includeImages": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}

Output

One dataset item represents one Shopify product.

Field	Description
productId	Shopify product ID, stringified.
title	Product title.
handle	Product URL handle or slug.
url	Canonical product page URL.
storeDomain	Store hostname without www.
vendor	Brand or vendor name.
productType	Shopify product type or category.
description	Plain-text product description with HTML stripped.
tags	Product tags array.
currency	Store currency code from meta.json.
price	Lowest variant price.
priceMax	Highest variant price.
compareAtPrice	Lowest compare-at price when present.
available	True when any variant is in stock.
variantsCount	Number of variants.
imagesCount	Number of images.
optionNames	Option dimension names such as Size or Color.
options	Option dimensions with their values.
featuredImage	Primary image URL.
images	All image URLs.
variants	Per-variant price, SKU, availability, and options.
createdAt	Product creation timestamp in ISO 8601.
updatedAt	Last update timestamp in ISO 8601.
publishedAt	Publish timestamp in ISO 8601.
scrapedAt	When the record was scraped in ISO 8601.

Illustrative output record

{
  "productId": "1234567890",
  "title": "Vital Seamless Leggings",
  "handle": "vital-seamless-leggings",
  "url": "https://gymshark.com/products/vital-seamless-leggings",
  "storeDomain": "gymshark.com",
  "vendor": "Gymshark",
  "productType": "Leggings",
  "description": "Seamless leggings with a high-rise fit.",
  "tags": [
    "leggings",
    "seamless"
  ],
  "currency": "USD",
  "price": 40,
  "priceMax": 50,
  "compareAtPrice": 60,
  "available": true,
  "variantsCount": 18,
  "imagesCount": 4,
  "optionNames": [
    "Color",
    "Size"
  ],
  "featuredImage": "https://cdn.shopify.com/example.jpg",
  "variants": [
    {
      "variantId": "987",
      "title": "Black / S",
      "sku": "GS-VSL-BLK-S",
      "price": 40,
      "available": true,
      "options": [
        "Black",
        "S"
      ]
    }
  ],
  "createdAt": "2025-11-20T10:15:30.000Z",
  "updatedAt": "2025-12-02T08:45:00.000Z",
  "publishedAt": "2025-11-21T09:00:00.000Z",
  "scrapedAt": "2026-01-01T00:00:00.000Z"
}

How it works

This Actor uses Shopify public JSON endpoints and HTTP-only requests:

1. Store URLs are fetched through https://<store>/products.json?limit=250&page=N and paginated until the catalog is collected or maxProducts is reached.
2. Collection URLs use /collections/<handle>/products.json.
3. Product URLs use the product .json endpoint and return one detailed record each.
4. Store currency is read from meta.json.
5. Requests use retry and backoff, and the data is flattened into a stable dataset schema.

Pricing

This Actor uses Pay per event pricing on the Apify platform together with standard Apify platform usage. Charged events include the run start event and the Product scraped event. Open the live Pricing tab in the Actor console to review the current rates.

Example in words: a run that starts and scrapes one thousand products is billed for one start event plus one thousand Product scraped events.

Use with AI agents (MCP)

This Actor is available as an Apify Actor usable through Apify MCP. The exact Actor identity is khadinakbar/shopify-products-scraper.

Tool description: use it when an agent needs structured Shopify product records from a store domain, collection URL, or product URL. The output is a dataset with one row per product, which helps an agent reason about catalog scope, pricing, availability, images, and variants.

Scrape this Shopify store URL and return the product rows with title, price, variants, images, availability, and timestamps. If I send a collection URL, limit the run to that category. If I send product URLs, return one row per product page.

Output interpretation:

• Each dataset row maps to one product record.
• price and priceMax describe the variant price range.
• variantsCount and imagesCount help an agent assess the record shape.
• scrapedAt provides record-level provenance.
• storeDomain keeps batched stores easy to group and compare.

Scope, pagination, and cost guidance:

• Store URLs collect the full catalog for each target.
• Collection URLs collect the products in one collection.
• Product URLs return one record per URL.
• Pagination continues until the source is exhausted or maxProducts is reached.
• Billing follows product events, so maxProducts is a practical way to shape run size.

Apify API example

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({
  token: process.env.APIFY_TOKEN,
});

const run = await client.actor('khadinakbar/shopify-products-scraper').call({
  storeUrls: ['gymshark.com'],
  includeVariants: true,
  includeImages: true,
  maxProducts: 50,
});

const datasetItems = await client.dataset(run.defaultDatasetId).listItems();

console.log(datasetItems.items);

Best results and outcome guidance

Choose the input type that matches the URL you already have:

• Use a store domain when you want a full catalog snapshot.
• Use a collection URL when you want a category-specific extract.
• Use a product URL when you are working from a shortlist of known items.
• Keep includeVariants enabled when pricing and option detail matter.
• Keep includeImages enabled when downstream systems use product media.
• Use maxProducts to shape the run size for large stores or multi-store batches.

Focused standalone workflow

This Actor is designed as a focused standalone workflow.

Design note

I found that the output contract requires productId, title, url, and scrapedAt, which makes each dataset row a self-contained product record with provenance.

FAQ

Which Shopify URLs fit this Actor?
Store domains, Shopify collection pages, and individual Shopify product pages each fit a different scrape scope.

What does one output row represent?
One row represents one Shopify product, even when the record includes variants and images.

How should I choose between store, collection, and product inputs?
Use store URLs for catalog-wide coverage, collection URLs for a category slice, and product URLs for a known list of product pages.

Can I batch multiple stores in one run?
Yes. storeUrls accepts multiple entries, so you can scrape several Shopify stores in one execution.

How does this Actor fit into Apify MCP workflows?
It can be called as khadinakbar/shopify-products-scraper from MCP-enabled clients to return structured Shopify product data as a dataset.

Responsible use

This Actor collects publicly available Shopify product data from storefront endpoints. Use the output in ways that respect the target site terms, applicable laws, and your own data-handling policies.