Shopify Store Intelligence

Analyze any Shopify-powered online store and extract its complete product catalog, pricing data, installed apps, theme information, and competitive metrics -- all without needing a Shopify API key. Feed it one URL or a hundred. For each store you get back product details with pricing, on-sale and stock status, the Shopify theme in use, the store currency, a list of detected third-party apps (Klaviyo, Yotpo, Afterpay, and 35+ others), plus aggregate statistics like average price, price range, vendor breakdown, product types, and top tags.

This actor uses Shopify's public /products.json endpoint combined with HTML analysis of the store's homepage. No authentication or store owner permission is required -- it collects the same information any visitor can see in their browser.

Why use Shopify Store Intelligence on Apify?

Manually reviewing a competitor's Shopify store is tedious. You have to browse through products page by page, view source to find their theme and installed apps, and there is no built-in way to export the data or track changes over time. The alternative -- building your own scraper -- requires handling URL normalization, pagination, proxy rotation, Shopify detection, and app fingerprinting.

This actor handles all of that. Running on Apify's cloud:

• No API key needed -- Works entirely through publicly accessible Shopify endpoints.
• Batch analysis -- Process hundreds of stores in a single run with automatic deduplication by domain.
• App detection -- Identifies 40+ third-party Shopify apps from the HTML source, including reviews, email marketing, buy-now-pay-later, analytics, and page builders.
• Pricing analytics -- Calculates min/max/average prices, sale counts, and out-of-stock percentages across the entire catalog.
• Scheduled monitoring -- Track competitor stores weekly or monthly with Apify's scheduler.
• Proxy support -- Built-in Apify proxy integration for reliable access at scale.

Key features

• Shopify detection -- Automatically confirms whether each URL is actually a Shopify store before attempting data extraction.
• Full product catalog extraction -- Fetches every product via the public /products.json endpoint with pagination support for stores with thousands of SKUs.
• Pricing analytics -- Calculates min/max price range, average price, sale counts, and compare-at-price data across the entire catalog.
• Theme identification -- Detects the active Shopify theme name and ID from the page source.
• App detection (40+ apps) -- Identifies installed third-party apps including review platforms, email/SMS marketing, buy-now-pay-later, page builders, analytics, and customer support tools.
• Stock monitoring -- Flags out-of-stock products and tracks available inventory status per variant.
• Vendor and category breakdown -- Extracts unique vendors, product types, and the top 20 most-used tags.
• Bulk analysis -- Process hundreds of Shopify stores in a single run with deduplication.
• No API key required -- Works entirely through publicly accessible Shopify endpoints.

Use cases

Competitor analysis for e-commerce brands -- A DTC skincare brand monitors 15 competitor Shopify stores weekly. They track productCount, averagePrice, and onSaleCount over time to spot pricing trends and promotional patterns. When a competitor adds Afterpay, they know it is time to add BNPL to their own store.

Dropshipping niche research -- A dropshipper evaluates 50 stores in the pet accessories niche by running a single batch. They compare average prices, vendor diversity (how many suppliers each store uses), and catalog sizes to identify profitable niches with low competition.

SaaS sales prospecting -- A Shopify app company targets stores that are missing their email marketing tool. They run the actor on 200 stores in a vertical, filter for those without Klaviyo or Omnisend in detectedApps, and add them to their outreach pipeline.

Market research for investors -- A venture capital analyst evaluates a portfolio company's competitive landscape by analyzing 30 DTC brands in the same category. They compare catalog sizes, pricing strategies, and tech stack maturity.

Agency client audits -- A Shopify development agency runs the actor on a prospect's store before the sales call. They identify optimization opportunities in the theme, missing apps (e.g., no review platform, no analytics beyond basic GA), and pricing strategy.

Brand protection -- A brand owner monitors unauthorized resellers by scanning Shopify stores selling their products. They filter the vendors field for their brand name across hundreds of stores.

How to use Shopify Store Intelligence

1. Provide store URLs -- Enter one or more Shopify store URLs in the input. The actor accepts any format: allbirds.com, https://www.gymshark.com, or https://kith.com/.
2. Set product limits -- Choose how many products to fetch per store (default 250, max 10,000). Set lower for quick audits or higher for complete catalog dumps.
3. Choose output detail -- Enable "Include full product list" for individual product data, or disable it to get only store-level summary statistics.
4. Run and export -- Start the actor and download results as JSON, CSV, or Excel. Each store produces one result row with all metrics and an embedded product array.

Input parameters

Parameter	Type	Required	Default	Description
urls	String[]	Yes	-	List of Shopify store URLs to analyze. Accepts any format.
maxProducts	Integer	No	250	Maximum number of products to fetch per store (1-10,000).
includeProducts	Boolean	No	true	Include the full product list in output, or only store-level stats.
proxyConfiguration	Object	No	-	Proxy settings for HTTP requests.

Input examples

Single store deep dive:

{
    "urls": ["https://allbirds.com"],
    "maxProducts": 5000,
    "includeProducts": true
}

Batch competitor scan (summary only):

{
    "urls": [
        "allbirds.com",
        "gymshark.com",
        "kith.com",
        "cotopaxi.com",
        "bombas.com",
        "brooklinen.com"
    ],
    "maxProducts": 250,
    "includeProducts": false
}

Full catalog with proxy:

{
    "urls": ["https://fashionnova.com"],
    "maxProducts": 10000,
    "includeProducts": true,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
}

Input tips

• Start without the product list -- Set includeProducts to false for initial screening of many stores. Once you identify interesting targets, re-run with products enabled.
• Use lower product limits for speed -- If you only need pricing trends and app detection, fetching 50-100 products is usually enough for representative statistics.
• Batch related stores together -- The actor deduplicates URLs by domain, so you can paste in a large list without worrying about duplicates wasting compute time.
• URL format is flexible -- You can mix formats freely: allbirds.com, www.allbirds.com, https://allbirds.com all resolve to the same store.

Output example

Each store produces a single result object:

{
    "url": "https://allbirds.com",
    "domain": "allbirds.com",
    "isShopify": true,
    "storeName": "Allbirds",
    "theme": "Custom Theme",
    "themeId": 139483726,
    "currency": "USD",
    "productCount": 87,
    "totalProductsFetched": 87,
    "priceRange": {
        "min": 18.0,
        "max": 220.0
    },
    "averagePrice": 104.52,
    "onSaleCount": 12,
    "outOfStockCount": 4,
    "vendors": ["Allbirds"],
    "productTypes": ["Shoes", "Socks", "Apparel", "Accessories"],
    "topTags": [
        { "tag": "mens", "count": 42 },
        { "tag": "womens", "count": 39 },
        { "tag": "shoes", "count": 34 },
        { "tag": "new-arrivals", "count": 15 },
        { "tag": "sale", "count": 12 }
    ],
    "detectedApps": [
        "Afterpay",
        "Google Analytics",
        "Google Tag Manager",
        "Klaviyo",
        "Meta Pixel",
        "Segment",
        "TikTok Pixel",
        "Yotpo Reviews"
    ],
    "products": [
        {
            "title": "Men's Tree Runners",
            "handle": "mens-tree-runners",
            "vendor": "Allbirds",
            "type": "Shoes",
            "price": 98.0,
            "compareAtPrice": null,
            "onSale": false,
            "variants": 12,
            "inStock": true,
            "createdAt": "2023-06-15T10:30:00-04:00",
            "imageUrl": "https://cdn.shopify.com/s/files/1/0070/1922/products/mens-tree-runners.jpg",
            "url": "https://allbirds.com/products/mens-tree-runners",
            "tags": ["mens", "shoes", "tree", "runners", "bestseller"]
        }
    ],
    "analyzedAt": "2025-01-15T14:22:33.000Z"
}

Output fields -- store level

Field	Type	Description
url	String	The URL as provided in the input
domain	String	Normalized domain name (e.g., allbirds.com)
isShopify	Boolean	Whether the site was confirmed as a Shopify store
storeName	String/null	Store name extracted from Shopify metadata or meta tags
theme	String/null	Active Shopify theme name
themeId	Number/null	Shopify theme ID
currency	String/null	Store currency code (e.g., USD, GBP, EUR)
productCount	Number	Total number of products found
totalProductsFetched	Number	Number of products actually fetched (may be less than total if capped by maxProducts)
priceRange	Object/null	{ min, max } price range across all products
averagePrice	Number/null	Average product price (rounded to 2 decimal places)
onSaleCount	Number	Number of products with a compare-at price higher than the current price
outOfStockCount	Number	Number of products with no available variants
vendors	String[]	Sorted list of unique vendor/brand names
productTypes	String[]	Sorted list of unique product type categories
topTags	Object[]	Top 20 most-used tags with counts: [{ tag, count }]
detectedApps	String[]	Sorted list of detected third-party apps and services
products	Object[]	Full product list (empty if includeProducts is false)
analyzedAt	String	ISO timestamp of when the analysis was performed

Output fields -- product level

Field	Type	Description
title	String	Product title
handle	String	URL-friendly product handle
vendor	String	Vendor/brand name
type	String	Product type category
price	Number	Price of the first variant (parsed to number)
compareAtPrice	Number/null	Original price before discount (null if not on sale)
onSale	Boolean	True if compare-at price exists and is higher than current price
variants	Number	Number of variants (sizes, colors, etc.)
inStock	Boolean	True if at least one variant is available
createdAt	String	ISO timestamp when the product was created
imageUrl	String/null	URL of the first product image
url	String	Full URL to the product page
tags	String[]	Product tags assigned in Shopify admin

How much does it cost?

Shopify Store Intelligence uses pay-per-event pricing -- you pay $0.50 per store analyzed. Platform usage costs are included in the price.

Scenario	Stores	Cost per store	Total cost
Quick audit	1	$0.50	$0.50
Competitor batch	10	$0.50	$5.00
Niche research	50	$0.50	$25.00
Large-scale research	100	$0.50	$50.00

You can set a maximum spending limit per run to control costs. The actor will stop analyzing stores once your budget is reached, so you never pay more than you expect.

Apify Free Tier: New Apify accounts receive $5 of free platform credits each month, enough for 10 store analyses.

Analyze Shopify stores using the API

Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_API_TOKEN")

run_input = {
    "urls": ["allbirds.com", "gymshark.com", "kith.com"],
    "maxProducts": 250,
    "includeProducts": False,
}

run = client.actor("ryanclinton/shopify-store-intelligence").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['domain']}: {item['productCount']} products, "
          f"avg ${item['averagePrice']}, apps: {', '.join(item['detectedApps'])}")

JavaScript

import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: "YOUR_APIFY_API_TOKEN" });

const run = await client.actor("ryanclinton/shopify-store-intelligence").call({
    urls: ["allbirds.com", "gymshark.com", "kith.com"],
    maxProducts: 250,
    includeProducts: false,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.log(`${item.domain}: ${item.productCount} products, avg $${item.averagePrice}`);
    console.log(`  Apps: ${item.detectedApps.join(", ")}`);
});

cURL

# Start the actor
curl -X POST "https://api.apify.com/v2/acts/ryanclinton~shopify-store-intelligence/runs?token=YOUR_APIFY_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "urls": ["allbirds.com", "gymshark.com"],
    "maxProducts": 250,
    "includeProducts": false
  }'

# Retrieve results (use the defaultDatasetId from the run response)
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_APIFY_API_TOKEN&format=json"

How it works

1. URL normalization -- Each input URL is cleaned and normalized. The actor strips paths, adds https:// if missing, and deduplicates by domain name so the same store is never analyzed twice.

2. Shopify detection -- The actor fetches each store's homepage HTML using CheerioCrawler and checks for Shopify signatures: references to Shopify. JavaScript objects, cdn.shopify.com asset URLs, or myshopify.com domains. Non-Shopify sites are flagged with isShopify: false and returned with empty data.

3. Theme and metadata extraction -- For confirmed Shopify stores, the actor parses the homepage HTML to extract the Shopify.theme JavaScript object (theme name and ID), Shopify.currency (active currency code), and the store name from Shopify.shop or OpenGraph meta tags.

4. App detection -- The full HTML source is scanned against 40+ regex patterns that match known third-party app script URLs and identifiers. For example, klaviyo.com in the source indicates Klaviyo is installed, afterpay.com indicates Afterpay, and so on. Results are deduplicated and sorted alphabetically.

5. Product catalog fetching -- The actor calls the public /products.json endpoint with pagination (250 products per page). It pages through until all products are fetched or the maxProducts limit is reached. Products that return a 404 or 403 mean the store has disabled the public endpoint.

6. Analytics computation -- For each store, the actor computes aggregate statistics: price range (min/max), average price (from first-variant prices), on-sale count (products where compare_at_price > price), out-of-stock count (products with no available variants), unique vendors, unique product types, and the top 20 most-used tags.

7. Output -- One result object per store is pushed to the Apify dataset with all store-level metrics and optionally the full product array.

Detected apps reference

The actor recognizes 40+ Shopify apps and third-party services by scanning the store's HTML source:

Category	Apps Detected
Reviews	Yotpo, Judge.me, Loox, Stamped.io, Okendo
Email / SMS	Klaviyo, Omnisend, Mailchimp, Attentive, Postscript
Pop-ups & Conversion	Privy, Justuno
Loyalty & Referrals	Smile.io, ReferralCandy
Subscriptions	ReCharge
Buy Now Pay Later	Afterpay, Klarna, Sezzle
Page Builders	PageFly, Shogun, GemPages, Zipify Pages
Analytics	Google Analytics, Google Tag Manager, Hotjar, Segment, Lucky Orange
Advertising	Meta Pixel, TikTok Pixel, Pinterest Tag, LinkedIn Insight Tag
Customer Support	Zendesk, Gorgias, Intercom, Tidio
Dropshipping	Oberlo, DSers
Other	Bold Commerce, Back in Stock, Wishlist, Shopify App Bridge

Detection is based on script URL patterns in the HTML source. Apps that load entirely via Shopify's app proxy or backend-only apps may not be detected.

Tips for best results

• Start without the product list -- Set includeProducts to false for initial screening of many stores. Once you identify interesting targets, re-run with products enabled for the deep dive.
• Use lower product limits for speed -- If you only need pricing trends and app detection, fetching 50-100 products is usually enough to get representative statistics without waiting for full pagination.
• Batch related stores together -- The actor deduplicates URLs by domain, so you can paste in a large list without worrying about duplicates wasting compute time.
• Check isShopify first -- When processing mixed URL lists, filter results by isShopify: true to separate confirmed Shopify stores from non-Shopify sites.
• Schedule recurring runs -- Use Apify Schedules to monitor competitor stores weekly. Compare productCount, averagePrice, and onSaleCount over time to spot trends.
• Use proxy for large batches -- Enable Apify proxy for runs with 50+ stores to avoid rate limiting or IP blocks.

Combine with other actors

• Website Tech Stack Detector -- Broader technology detection beyond Shopify, covering CMS platforms, frameworks, CDNs, and analytics tools for any website.
• Website Contact Scraper -- Extract emails, phone numbers, and social media links from the stores you analyze to build a contact list for outreach.
• E-Commerce Price Monitor -- Track product prices over time across e-commerce sites with automated change detection and alerts.
• Brand Protection Monitor -- Monitor the web for unauthorized use of your brand name, trademarks, and product listings.
• WHOIS Domain Lookup -- Get domain registration details, ownership info, and expiration dates for the stores you analyze.
• SaaS Competitive Intelligence -- Deeper competitive analysis combining multiple data sources for market research beyond Shopify.
• Website Content to Markdown -- Extract the full page content of any store's landing pages for content analysis and comparison.

Limitations

• Public endpoint only -- The actor relies on Shopify's /products.json endpoint. Some stores disable this endpoint, in which case you will get theme and app data from HTML analysis but zero products.
• First-variant pricing -- Product prices are extracted from the first variant only. If a product has variants with different prices (e.g., sizes), the price shown is for the first/default variant.
• App detection is pattern-based -- Apps are detected by scanning HTML source for known script URL patterns. Apps that load entirely via Shopify's backend, app proxy, or server-side injection may not be detected. The list covers 40+ popular apps but is not exhaustive.
• No historical data -- Each run captures a point-in-time snapshot. To track changes over time, schedule recurring runs and compare datasets.
• Non-Shopify sites -- The actor only extracts product data from Shopify stores. Non-Shopify sites are returned with isShopify: false and empty product data.
• Rate limiting -- Fetching very large catalogs (5,000+ products) from a single store may encounter Shopify's rate limiting. The actor handles this gracefully but some products may be missed.
• Currency is store-level -- The currency field reflects the store's primary currency. Multi-currency stores will show the default currency only.

Responsible use

• Public data -- This actor accesses only publicly available data through Shopify's standard /products.json endpoint and the store's homepage HTML. It collects the same information any customer can see by visiting the store.
• Terms of service -- Always review and comply with each store's terms of service before large-scale data collection. Some stores may prohibit automated access.
• Rate limiting -- Keep maxProducts and batch sizes reasonable. Avoid scheduling runs more frequently than necessary for your analysis needs.
• Contact data -- This actor does not extract personal contact information. Store names and vendor names are business identifiers, not personal data.
• Competitive intelligence -- Use the data for legitimate business analysis, market research, and competitive benchmarking purposes.

FAQ

Is it legal to scrape Shopify stores? This actor accesses only publicly available data through Shopify's standard /products.json endpoint, which is accessible to any web browser. It collects the same information any customer can see by visiting the store. Always review and comply with each store's terms of service before large-scale collection.

Do I need a Shopify API key? No. The actor uses Shopify's public product endpoint that requires no authentication. It works on any Shopify store that has not explicitly blocked this endpoint.

What if a store blocks /products.json? Some stores disable the public products endpoint. In that case the actor will still detect the theme, currency, store name, and installed apps from the homepage HTML -- you will just get zero products.

How many apps can it detect? The actor recognizes 40+ popular Shopify apps and third-party services. See the detected apps reference table above for the full list by category.

Can I analyze non-Shopify stores? The actor will flag non-Shopify stores with isShopify: false in the output. It does not extract product data from other platforms like WooCommerce, Magento, or BigCommerce.

How accurate is the pricing data? Prices come directly from Shopify's product API and reflect the current listed price of the first variant. Compare-at prices are included when available, letting you identify which products are on sale and by how much.

What is the maximum number of stores I can analyze? There is no hard limit. The actor processes stores sequentially. For very large batches (500+ stores), consider breaking them into smaller runs to manage timeout and memory.

Can I get results in CSV or Excel format? Yes. After the actor completes, click "Export" on the dataset page and choose CSV, Excel, JSON, or other formats. The Apify API also supports format=csv and format=xlsx query parameters. Note that the nested products array will be flattened in tabular formats.

Integrations

• Google Sheets -- Export results directly to Google Sheets using the Apify integration. Ideal for maintaining a live competitor tracking spreadsheet.
• Slack / Email -- Get notifications when a run completes with summary statistics.
• Webhooks -- Push results to your CRM, data warehouse, or custom pipeline.
• Zapier / Make -- Connect to thousands of apps for custom automation workflows.
• REST API -- Call the actor programmatically via the Apify API. Start runs, poll for status, and download datasets in JSON, CSV, XML, or Excel format.
• Python & JavaScript SDKs -- Use the official Apify SDKs to integrate store intelligence into your own applications and data pipelines.

Support

Found a bug or have a feature request? Open an issue in the Issues tab on this actor's page. For custom e-commerce intelligence solutions, reach out through the Apify platform.