Shopify Product Scraper

Extract products, prices, variants, and images from any Shopify store. Uses Shopify's built-in JSON API for the fastest and most reliable extraction -- no browser needed.

What does Shopify Product Scraper do?

Shopify Product Scraper extracts complete product data from any Shopify-powered online store. It leverages Shopify's native /products.json API endpoint, which means it is significantly faster and more reliable than scrapers that parse HTML. No browser rendering, no JavaScript execution -- just clean, structured JSON data.

The actor supports multiple input methods: provide a store URL to scrape all products, a collection URL to scrape a specific category, or individual product URLs for targeted extraction. It automatically handles pagination (up to 250 products per page) and deduplicates results.

Every product includes full variant data (sizes, colors, SKUs, individual prices), all product images with dimensions and alt text, tags, vendor information, and availability status -- making it ideal for price monitoring, competitor analysis, and product research.

Use Cases

• Competitor price monitoring -- Track competitor prices and stock levels across Shopify stores. Get compare-at prices to detect discounts and sales.
• Product research & dropshipping -- Find trending products, compare vendors, and analyze product catalogs for dropshipping opportunities.
• Market analysis -- Analyze product categories, pricing strategies, and inventory across multiple Shopify stores.
• Data analysts -- Build product databases, price history datasets, and e-commerce market intelligence reports.
• Developers -- Integrate Shopify product data into your apps via Apify API, webhooks, or direct dataset access.

Features

• Scrape ALL products from any Shopify store
• Support for store URLs, collection URLs, and individual product URLs
• Full variant extraction: size, color, SKU, price per variant
• All product images with alt text and dimensions
• Compare-at prices for discount tracking
• Automatic pagination (250 products per page, Shopify max)
• Built-in deduplication
• Uses Shopify JSON API -- fastest possible extraction
• Proxy support for stores that rate-limit
• Exports to JSON, CSV, Excel, or connect via API

Pricing

This actor is free to use -- you only pay for Apify platform compute time.

Products	Estimated Cost	Time
100	~$0.01	~10s
1,000	~$0.05	~1min
10,000	~$0.25	~5min

Costs are minimal because the actor uses HTTP requests only (no browser), and most Shopify stores do not require proxies.

How to use

1. Go to the Shopify Product Scraper page on Apify Store
2. Click "Start" or "Try for free"
3. Enter one or more Shopify store URLs, collection URLs, or product URLs
4. Set the maximum number of products to scrape
5. Click "Start" and wait for results

How to find Shopify stores

Shopify stores can be identified in several ways:

• Direct Shopify domains: Many stores use store-name.myshopify.com
• Custom domains: Most stores use custom domains. You can check if a site is Shopify by visiting example.com/products.json -- if it returns JSON data, it is a Shopify store.
• Built With tools: Use services like BuiltWith or Wappalyzer to detect Shopify-powered sites.
• Page source: Look for cdn.shopify.com in the page source code.

Input parameters

Parameter	Type	Description	Default
startUrls	array	Shopify store, product, or collection URLs	-
maxItems	number	Maximum products to scrape (0 = unlimited)	100
includeVariants	boolean	Include size/color/SKU variants	true
includeHtml	boolean	Include raw HTML product description	false
proxyConfig	object	Proxy settings (usually not needed)	No proxy

Output

The actor produces a dataset with the following fields:

{
    "url": "https://www.allbirds.com/products/wool-runners",
    "title": "Men's Wool Runners",
    "handle": "wool-runners",
    "vendor": "Allbirds",
    "productType": "Shoes",
    "tags": ["mens", "runners", "wool"],
    "price": 110,
    "compareAtPrice": null,
    "currency": null,
    "available": true,
    "description": "Our original shoe, made with superfine merino wool...",
    "images": [
        {
            "src": "https://cdn.shopify.com/s/files/1/image.jpg",
            "alt": "Men's Wool Runners",
            "width": 1600,
            "height": 1600
        }
    ],
    "variants": [
        {
            "title": "8 / Natural Black (Black Sole)",
            "price": 110,
            "compareAtPrice": null,
            "sku": "WR-NNZ-NB-M8",
            "available": true,
            "option1": "8",
            "option2": "Natural Black (Black Sole)",
            "option3": null
        }
    ],
    "createdAt": "2023-05-15T10:30:00-04:00",
    "updatedAt": "2024-12-01T08:15:00-05:00",
    "scrapedAt": "2026-04-23T14:30:00.000Z"
}

Field	Type	Description
url	string	Product page URL
title	string	Product title
handle	string	URL-friendly product slug
vendor	string	Brand or vendor name
productType	string	Product category
tags	array	Product tags
price	number	Lowest variant price
compareAtPrice	number	Original price (before discount)
currency	string	Currency code (when available)
available	boolean	Whether any variant is in stock
description	string	Plain text product description
images	array	Product images with src, alt, dimensions
variants	array	Variants with title, price, sku, options
createdAt	string	Product creation date
updatedAt	string	Last update date
scrapedAt	string	ISO 8601 scrape timestamp

Integrations

Connect Shopify Product Scraper with other tools:

• Apify API -- REST API for programmatic access
• Webhooks -- Get notified when a run finishes
• Zapier / Make -- Connect to 5,000+ apps
• Google Sheets -- Export directly to spreadsheets

API Example (Node.js)

import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('YOUR_USERNAME/shopify-product-scraper').call({
    startUrls: [{ url: 'https://www.allbirds.com' }],
    maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

API Example (Python)

from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')
run = client.actor('YOUR_USERNAME/shopify-product-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.allbirds.com'}],
    'maxItems': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

API Example (cURL)

curl "https://api.apify.com/v2/acts/YOUR_USERNAME~shopify-product-scraper/runs" \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -d '{"startUrls": [{"url": "https://www.allbirds.com"}], "maxItems": 100}'

Tips and tricks

• Start with a small maxItems (10-20) to test before running large scrapes
• Most Shopify stores work without proxies. Enable Apify Proxy only if you hit rate limits.
• Use collection URLs to scrape specific product categories (e.g., https://store.com/collections/sale)
• The actor scrapes up to 250 products per API call, making it extremely fast
• Set includeVariants: true to get per-variant pricing for accurate price comparison
• Use includeHtml: false (default) for cleaner data; enable it only if you need rich text formatting

FAQ

Q: Does this actor require login credentials? A: No. It only accesses publicly available product data through Shopify's JSON API.

Q: How fast is the scraping? A: Extremely fast. The actor can scrape 1,000+ products per minute since it uses direct JSON API calls without browser rendering.

Q: What should I do if I get blocked? A: Enable Apify Proxy in the Proxy Configuration settings. Datacenter proxies usually work; switch to residential if needed.

Q: Does it work with password-protected stores? A: No. Password-protected Shopify stores block API access. The actor will report an access denied error.

Q: Why is currency sometimes null? A: Shopify's /products.json endpoint does not include currency information. Prices are in the store's default currency (usually visible on the storefront).

Q: Can I scrape specific collections? A: Yes. Provide a collection URL like https://store.com/collections/sale and the actor will only scrape products from that collection.

Is it legal to scrape Shopify stores?

Web scraping of publicly available data is generally legal based on precedents like the LinkedIn v. HiQ Labs case. This actor only accesses publicly available product data through Shopify's built-in JSON API. Always review and respect the target store's Terms of Service. For more information, see Apify's blog on web scraping legality.

Limitations

• Password-protected Shopify stores cannot be scraped
• Currency is not included in the JSON API response (prices are in the store's default currency)
• Some stores may rate-limit requests; use proxy configuration if this happens
• The Shopify JSON API has a maximum of 250 products per page
• Very large stores (50,000+ products) may take longer due to pagination

Changelog

• v0.1 (2026-04-23) -- Initial release