# Shopify Store Analyzer (`deriverge/shopify-store-analyzer`) Actor

Apps, theme and catalog statistics for a list of Shopify stores, one row per store with settings such as currency, shipping countries and product count. Up to 25,000 products per store feed the price and discount figures, and scheduled runs report apps and themes that changed.

- **URL**: https://apify.com/deriverge/shopify-store-analyzer.md
- **Developed by:** [deriverge s.r.o.](https://apify.com/deriverge) (community)
- **Categories:** E-commerce, Lead generation, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 stores

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Shopify Store Analyzer

Shopify Store Analyzer turns a list of Shopify stores into one row per store: the settings the store publishes (name, currency, business country, shipping countries, product and collection counts, Shop Pay), its live theme and version, the apps and tracking pixels on its homepage, and statistics over up to 25,000 products, from price range and discount share to top product types and new launches. Paste store domains and click **Start**. Only the homepage is scanned for apps, so tools that load on product or checkout pages can be missed. It costs $2.00 per 1,000 stores on the Free plan ($1.00 on Business), and the $5 of monthly credit in Apify's Free plan covers about 2,500 stores.

### What does one row contain?

| Field | Description |
|---|---|
| `status`, `error` | `ok` for an analyzed store, the only status that is charged. `catalog_hidden` marks a Shopify store whose custom storefront hides its settings and catalog; `not_shopify`, `blocked`, `unreachable`, `robots_disallowed` (the store's robots.txt disallows its feed or homepage) and `invalid_input` come with the reason in `error`. |
| `name`, `description` | Store name and the store's own description from its settings. |
| `myshopifyDomain`, `shopId` | The permanent Shopify address, such as `weareallbirds.myshopify.com`, and Shopify's numeric shop ID. |
| `city`, `province`, `country` | City, state and country code of the business address in the store settings, such as `Beverly Hills`, `California` and `US`. |
| `currency` | The store's default currency. Every price in the row is in it. |
| `shipsToCountries` | Codes of the countries the store ships to: only `US` for Allbirds, 184 codes for ColourPop in October 2026. |
| `productsCount`, `collectionsCount` | Published products and collections as the store reports them. |
| `offersShopPayInstallments`, `shopPayCardBrands` | Whether Shop Pay Installments is on, and the card brands Shop Pay takes, such as `visa` or `american_express`. |
| `themeName`, `themeSchemaName`, `themeVersion` | The live theme as the store labeled it (often an internal name such as `[DNAM Theme July 2026]`), the theme it is built on, such as `Dawn`, and that theme's version. |
| `themeStoreId` | ID of the theme in the Shopify Theme Store, or `null` when the store reports none, as with custom themes. |
| `productsAnalyzed`, `catalogComplete` | How many products the statistics cover, and `true` when that is every published product. |
| `minPrice`, `medianPrice`, `averagePrice`, `maxPrice` | Price figures over the analyzed products, with each product counted at its lowest variant price. |
| `discountedShare`, `inStockShare` | Share of products with a compare-at price above the price, and share with at least one variant in stock, from 0 to 1. |
| `averageVariants` | Mean number of variants (sizes, colors) per product. |
| `topProductTypes`, `topVendors` | Up to 8 most common product types and vendors with their counts. |
| `newestProductAt`, `oldestProductAt` | Creation dates of the newest and the oldest analyzed product. |
| `productsAddedLast30Days`, `productsUpdatedLast30Days` | Analyzed products created, and products changed, in the 30 days before the run. |
| `apps` | Third-party services found on the homepage in app categories such as reviews, email and marketing automation, loyalty, referrals, chat, shipping, returns, translation and buy now pay later, for example `Attentive` and `Yotpo Reviews`. |
| `reviews`, `marketingAutomation`, `liveChat`, `payments`, `cookieConsent` | Findings sorted by kind, such as `Apple Pay` and `PayPal` under `payments`. |
| `analytics`, `advertising` | Analytics tools and ad pixels, including those that Google Tag Manager loads, such as `Facebook Pixel` or `Google Ads`. |
| `emailServices` | Mailbox provider read from the MX records and sending services from the SPF record, such as `Microsoft 365`. |
| `technologyNames` | Everything detected on the homepage and in DNS, including hosting and security tools. |
| `newApps`, `removedApps`, `previousTheme`, `productsCountChange` | With a watch name, what moved since the previous run. `null` on a first run. |
| `checkedAt` | Time of the analysis in UTC. |

### How to analyze Shopify stores

1. Paste store domains into **Stores**, one per line, such as `allbirds.com` or `www.gymshark.com`. A full link works too, and only its domain is used. Four stores are read at a time.
2. Set **Products to analyze per store** between 1 and 25,000 (1,000 by default). A higher number makes the statistics exact for big catalogs and the run longer, at the same price per store.
3. Leave **Read DNS records** on to fill `emailServices` from the domain's mail records.
4. To compare runs, fill **Watch name (app and theme alerts)**, as described below.
5. Click **Start**. Each store becomes one row on the **Output** tab, ready for CSV, Excel or JSON export, or for the API.

The same run over the API, with a larger product sample and a watch name:

```json
{
  "stores": ["allbirds.com", "brooklinen.com", "gymshark.com"],
  "maxProductsPerStore": 5000,
  "scanDns": true,
  "watchName": "rival-stores"
}
```

### Example output

The Allbirds row from a run on 11 October 2026 with the default settings. The store listed 692 products, so all of them went into the statistics. The run had no watch name, which leaves the four change fields `null`.

```json
{
  "input": "allbirds.com",
  "store": "allbirds.com",
  "url": "https://www.allbirds.com/",
  "status": "ok",
  "error": null,
  "name": "Allbirds",
  "description": "The world’s most comfortable shoes, made with natural materials like merino wool, eucalyptus tree fiber, and sugar cane, Allbirds has created the comfiest shoes on the planet.",
  "myshopifyDomain": "weareallbirds.myshopify.com",
  "shopId": 11044168,
  "city": "Beverly Hills",
  "province": "California",
  "country": "US",
  "currency": "USD",
  "shipsToCountries": [
    "US"
  ],
  "productsCount": 692,
  "collectionsCount": 1346,
  "offersShopPayInstallments": true,
  "shopPayCardBrands": [
    "visa",
    "master",
    "discover",
    "american_express",
    "diners_club"
  ],
  "themeName": "[DNAM Theme July 2026]",
  "themeSchemaName": "allbirds-theme",
  "themeVersion": "1.231.12",
  "themeStoreId": null,
  "productsAnalyzed": 692,
  "catalogComplete": true,
  "minPrice": 0.8,
  "medianPrice": 105,
  "averagePrice": 94.25,
  "maxPrice": 165,
  "discountedShare": 0.21,
  "inStockShare": 0.54,
  "averageVariants": 10.77,
  "topProductTypes": [
    {
      "name": "Shoes",
      "count": 602
    },
    {
      "name": "Socks",
      "count": 57
    },
    {
      "name": "Apparel",
      "count": 22
    },
    {
      "name": "Underwear",
      "count": 3
    },
    {
      "name": "return,package_protection",
      "count": 1
    }
  ],
  "topVendors": [
    {
      "name": "Allbirds",
      "count": 691
    },
    {
      "name": "re:do",
      "count": 1
    }
  ],
  "newestProductAt": "2026-06-05T14:14:57.000Z",
  "oldestProductAt": "2018-11-12T22:25:43.000Z",
  "productsAddedLast30Days": 0,
  "productsUpdatedLast30Days": 692,
  "apps": [
    "Attentive",
    "Yotpo Reviews"
  ],
  "reviews": [
    "Yotpo Reviews"
  ],
  "analytics": [
    "Facebook Pixel",
    "Google Ads Conversion Tracking",
    "Google Analytics"
  ],
  "advertising": [
    "Adalyser",
    "Google Ads",
    "Microsoft Advertising",
    "Outbrain"
  ],
  "marketingAutomation": [
    "Attentive"
  ],
  "liveChat": [],
  "payments": [
    "Apple Pay",
    "PayPal"
  ],
  "cookieConsent": [],
  "emailServices": [
    "Microsoft 365"
  ],
  "technologyNames": [
    "Shopify",
    "Microsoft 365",
    "Apple Pay",
    "PayPal",
    "Adalyser",
    "Attentive",
    "Cloudflare",
    "Cursor",
    "Facebook Pixel",
    "Google Ads",
    "Google Ads Conversion Tracking",
    "Google Analytics",
    "Google Tag Manager",
    "HSTS",
    "ipify",
    "Microsoft Advertising",
    "Outbrain",
    "Priority Hints",
    "Swiper",
    "Yotpo Reviews",
    "DocuSign",
    "HTTP/3",
    "Miro",
    "Open Graph"
  ],
  "newApps": null,
  "removedApps": null,
  "previousTheme": null,
  "productsCountChange": null,
  "checkedAt": "2026-10-11T12:25:24.480Z"
}
```

### How much does it cost to analyze a Shopify store?

| | Free plan | Starter | Scale | Business |
|---|---|---|---|---|
| 1,000 stores | $2.00 | $1.60 | $1.30 | $1.00 |

You pay only for the events in the table. There is no start fee, and compute time and proxies are included.

Profiling 500 stores costs $1.00 on the Free plan and $0.50 on Business, whatever the number of products analyzed per store. Rows with a status other than `ok` carry their reason and are not charged, so websites in your list that do not run on Shopify cost nothing.

### Limits

- Apps and pixels are read from the homepage and from up to 2 Google Tag Manager containers it loads. A tool that appears only on product, cart or checkout pages, or only after a visitor accepts cookies, is not found.
- The catalog statistics describe the analyzed products only. The feed lists the most recently published products first (it did at Allbirds and Brooklinen in October 2026), so a partial read covers the newest part of a catalog. Gymshark listed 10,355 products on 11 October 2026, the default 1,000 covered less than a tenth of them, and `catalogComplete` was `false`.
- `productsUpdatedLast30Days` matched `productsAnalyzed` in all four stores analyzed on 11 October 2026, so it says little about real catalog work. `productsAddedLast30Days`, based on creation dates, separates stores better: 44 for Brooklinen and 0 for Allbirds that day.
- A store built on a custom (headless) storefront does not publish its settings or catalog. It gets `catalog_hidden` with the tools found on its homepage and in DNS; `huel.com` was one in October 2026.
- Some catalogs contain entries that are not products. Brooklinen's feed held items named `Content: ...` at a price of 0, which pulled its `minPrice` to 0.
- A store that answers with a bot protection page gets `blocked`, and a website without any Shopify trace gets `not_shopify`.
- The actor reads each store's `robots.txt` first and follows it. A store whose `robots.txt` disallows its store details and product feed gets a free `robots_disallowed` row; when only the homepage is disallowed, the row has no apps or theme. When `robots.txt` answers with a server error or not at all, the store is skipped in that run as `unreachable`.

### Tracking app and theme changes

Give the run a **Watch name**, such as `rival-stores`, or save the input as a task, and schedule it, for example weekly. The first run stores each store's apps, theme with version and product count. Every later run fills `newApps`, `removedApps`, `previousTheme` and `productsCountChange` on the analyzed rows, and the `CHANGES` record in the run's key-value store lists the stores where something moved. `previousTheme` is set only when the theme or its version changed. Stores are matched by the text you entered, so keep the list in the same form from run to run.

### FAQ

#### Is it legal to analyze Shopify stores?

Shopify storefronts publish their store settings and product catalog as JSON at fixed addresses. The actor reads those files, the homepage and public DNS records, with no login and no visit to the checkout. A row describes the business: the city and country come from the business address in the store settings, and no customer data is read. You are responsible for how you use the results.

#### How are apps recognized?

The homepage's script addresses, links and inline code, and the tags inside up to 2 Google Tag Manager containers, are matched against the open-source webappanalyzer fingerprint set, the same set our Tech Stack Detector uses. A finding counts as an app when it is a third-party service in one of 20 categories, among them Shopify apps, reviews, loyalty, cart abandonment, shipping, returns, personalisation, surveys and buy now pay later.

### Related scrapers

- [Shopify Products Scraper](https://apify.com/deriverge/shopify-products-scraper)
- [Tech Stack Detector](https://apify.com/deriverge/tech-stack-detector)
- [Domain WHOIS and DNS Lookup](https://apify.com/deriverge/domain-whois-dns-lookup)

### Support

This actor is built and maintained by deriverge s.r.o., a software company based in the Czech Republic. If a run fails or a field you need is missing, please open an issue in the **Issues** tab or write to us at info@deriverge.com. We respond in English and Czech. Runs can be scheduled in Apify Console or started from the **API** tab, which has examples for Python, JavaScript and cURL and works with Make, Zapier, n8n and the Apify MCP server. If the actor saves you time, a short review helps other people find it.

# Changelog

This Actor's version history is a separate document: https://apify.com/deriverge/shopify-store-analyzer/changelog.md

# Actor input Schema

## `stores` (type: `array`):

Store domains, one per line, for example allbirds.com or www.gymshark.com. Paste hundreds at once.

## `maxProductsPerStore` (type: `integer`):

How many products from each catalog feed the price, discount, stock and launch statistics. More is slower but exact for big stores.

## `scanDns` (type: `boolean`):

Detect the email provider and email sending services (Klaviyo, Google Workspace, Microsoft 365...) from public DNS records.

## `watchName` (type: `string`):

Give the run a name such as "competitors" and schedule it. Every later run with the same name fills newApps, removedApps, previousTheme and productsCountChange. Runs from a saved task are compared automatically.

## Actor input object example

```json
{
  "stores": [
    "allbirds.com",
    "colourpop.com"
  ],
  "maxProductsPerStore": 1000,
  "scanDns": true
}
```

# Actor output Schema

## `stores` (type: `string`):

One row per store with store details, theme, apps, tools and catalog statistics.

## `changes` (type: `string`):

Stores that added or removed apps, changed theme or catalog size since the previous run with the same watch name.

## `summary` (type: `string`):

Stores analyzed, not on Shopify, blocked and billed.

# 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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "stores": [
        "allbirds.com",
        "colourpop.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("deriverge/shopify-store-analyzer").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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "stores": [
        "allbirds.com",
        "colourpop.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("deriverge/shopify-store-analyzer").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 '{
  "stores": [
    "allbirds.com",
    "colourpop.com"
  ]
}' |
apify call deriverge/shopify-store-analyzer --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,deriverge/shopify-store-analyzer"
        }
    }
}
```

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 <APIFY_API_TOKEN>` 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/IadwhcZkzgPbFczuA/builds/n54AkPOfLzUVpWu6E/openapi.json
