# Shopify Store Intelligence (`itzcloud/shopify-intel`) Actor

Analyze Shopify stores in bulk: theme, installed apps (Klaviyo, Judge.me, Recharge, Gorgias…), exact product count, price range, currency, country, shipping markets, catalog stats and contacts. Works with headless stores. $6 per 1,000 stores; non-Shopify sites are free.

- **URL**: https://apify.com/itzcloud/shopify-intel.md
- **Developed by:** [Juan Orjuela](https://apify.com/itzcloud) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.00 / 1,000 store analyzeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Intelligence — Theme, Apps, Products & Pricing

**Analyze any Shopify store from its domain.** Get the theme, installed apps, product and collection counts, price range, currency, country, shipping markets, catalog stats and public contacts, in **one row per store**.

Built for **e-commerce agencies, Shopify app developers, investors and market analysts** who need to qualify and segment stores at scale.

- 🛍️ **Shopify-native data.** It reads the store's public `meta.json` and product feed, the same endpoints Shopify exposes to every visitor.
- 🧩 **App detection.** 100+ popular apps (Klaviyo, Judge.me, Recharge, Gorgias, Rebuy, Yotpo…), plus *any* Online Store 2.0 app embed and script-tag app, even ones that aren't in our list.
- ⚡ **Fast and cheap.** No headless browser. A store takes about 1-2 seconds.
- 💸 **$6 per 1,000 stores, and you only pay for Shopify stores.** Non-Shopify domains in your list are detected and returned free.

***

### What data do you get?

| Group | Fields |
|---|---|
| **Store** | `storeName`, `description`, `myshopifyDomain`, `country`, `province`, `city`, `currency`, `locale`, `shipsToCountries`, `shipsToCountriesCount` |
| **Catalog** | `productCount` (exact, from `meta.json`), `collectionCount`, `priceMin`, `priceMedian`, `priceAvg`, `priceMax`, `onSalePct` (share of products with a compare-at price), `topVendors`, `topProductTypes`, `newestProductAt`, `oldestProductAt`, `productSampleSize` |
| **Theme** | `theme.name`, `theme.schemaName` (e.g. Dawn), `theme.version`, `theme.themeStoreId`, `theme.isCustom` |
| **Apps** | `apps` + `appsByCategory` (reviews, email/SMS, subscriptions, upsell/cart, page builders, loyalty, support, shipping, BNPL, translation, attribution, search…), `otherAppEmbeds` (unlisted app embeds, by name), `appScriptHosts` (script-tag apps) |
| **Tech** | `technologies`: 270+ technologies such as analytics, ad pixels, payments, chat and consent |
| **Contacts** | `primaryEmail`, `emails`, `phones`, `socials` (Instagram, Facebook, TikTok, X, YouTube, LinkedIn, Pinterest) |
| **Status** | `isShopify`, `headless` (Hydrogen/custom storefront), `passwordProtected`, `websiteOk`, `errorType`, `hasData` (charged or not) |

### Use cases

- **Agencies & freelancers.** Find stores on an outdated theme, with no reviews app, or without email/SMS marketing, then pitch exactly what they're missing.
- **Shopify app developers.** Measure your competitors' install base and build lead lists of stores that use (or don't use) a given app.
- **Market & competitor research.** Compare catalog sizes, price points, discount depth and markets across a whole niche.
- **Investors & M\&A.** Screen DTC brands by catalog size, pricing, markets and tech sophistication.
- **Lead generation.** Get store contacts and social profiles, with a clean filter for "real Shopify store".

### How to use it

1. Paste store domains into **Store domains or URLs**, or paste a whole spreadsheet column into **Bulk paste**.
2. Optional: turn off **Catalog & pricing stats** or **Contacts** if you only need the theme and apps (faster runs).
3. Click **Start**, then export the results as CSV, Excel or JSON, or use them via API, webhooks, Make, Zapier or Google Sheets.

#### Input example

```json
{
  "stores": ["allbirds.com", "glossier.com", "deathwishcoffee.com"],
  "includeCatalogStats": true,
  "includeContacts": true
}
```

#### Output example (a real result, trimmed)

```json
{
  "domain": "deathwishcoffee.com",
  "isShopify": true,
  "headless": false,
  "storeName": "Death Wish Coffee",
  "myshopifyDomain": "deathwishcoffee.myshopify.com",
  "country": "US",
  "currency": "USD",
  "productCount": 145,
  "collectionCount": 124,
  "shipsToCountriesCount": 224,
  "theme": { "name": "Sept 10, 2026", "schemaName": "Dawn", "version": "10.0.0", "themeStoreId": null, "isCustom": true },
  "apps": ["Klaviyo", "Postscript", "Rebuy", "Smile.io", "Gorgias"],
  "appsByCategory": {
    "email-sms": ["Klaviyo", "Postscript"],
    "upsell-cart": ["Rebuy"],
    "loyalty-referrals": ["Smile.io"],
    "support-chat": ["Gorgias"]
  },
  "priceMin": 5,
  "priceMedian": 29.98,
  "priceMax": 90,
  "onSalePct": 15,
  "topProductTypes": [{ "name": "Apparel", "count": 37 }, { "name": "Coffee", "count": 34 }, { "name": "Accessories", "count": 25 }],
  "productSampleSize": 145,
  "socials": { "instagram": "https://www.instagram.com/deathwishcoffee", "facebook": "https://www.facebook.com/deathwishcoffee" }
}
```

The **Output** tab has ready-made table views: *Overview*, *Apps & tech*, *Catalog & pricing* and *Contacts*.

### Pricing

This actor uses **pay-per-event** pricing. Platform usage is included.

| Event | Price |
|---|---|
| Shopify store analyzed | **$0.006** ($6 per 1,000 stores) |
| Domain that is not a Shopify store (or doesn't respond) | **Free** |
| Run start | Apify's standard start fee (a fraction of a cent per run) |

Tip: set **Max cost per run** in the run options. The actor stops cleanly at your budget and keeps everything it has already delivered.

### FAQ

**How do you know a site is Shopify?**
From Shopify's own markers (theme object, `cdn.shopify.com` and `/cdn/shop/` assets, Shopify response headers) and the public `meta.json` endpoint.

**Does it work with headless stores (Hydrogen, Next.js)?**
Yes. When a custom storefront doesn't serve Shopify's JSON endpoints, the actor finds the store's `*.myshopify.com` domain in the page and reads the data there. In our benchmark that recovered 6 of 6 headless brands (e.g. SKIMS, Fashion Nova, Vuori). Those rows have `headless: true`.

**Is the product count exact?**
Yes. `productCount` comes from Shopify's `meta.json`. Price and vendor statistics are calculated from up to 250 products in the public product feed (`productSampleSize` tells you how many).

**Which apps can you detect?**
100+ popular apps by name, plus every Online Store 2.0 **app embed** (listed in `otherAppEmbeds`) and every **script-tag app** (listed in `appScriptHosts` by domain). Apps that only run in the admin or at checkout leave no trace on the storefront and can't be detected.

**Does it use a browser?**
No. It uses plain HTTP requests to public pages and JSON endpoints, which keeps it fast and cheap.

**Is this legal?**
The actor only reads publicly available storefront pages and the public JSON endpoints Shopify serves to any visitor. It doesn't log in and doesn't bypass password pages. You're responsible for how you use the data (e.g. GDPR or CAN-SPAM for outreach).

### More tools from the same developer

- **[Website & Domain Intelligence](https://apify.com/itzcloud/website-intel)**: emails, phones, socials, 270+ technologies, email provider (MX/SPF/DMARC) and domain age for any company domain.
- **[Email Domain Health & Deliverability Checker](https://apify.com/itzcloud/email-health)**: bulk SPF, DKIM, DMARC, MTA-STS, BIMI and blocklist checks with a deliverability score.

# Actor input Schema

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

Shopify store domains or URLs, one per line (e.g. <code>allbirds.com</code>). Non-Shopify websites are detected and returned free of charge.

## `storesText` (type: `string`):

Paste a whole column from a spreadsheet. Domains can be separated by new lines, commas, semicolons or spaces. Combined with the list above.

## `includeCatalogStats` (type: `boolean`):

Reads the public product feed (up to 250 products) to compute price range, median and average price, % of products on sale, top vendors and product types, and newest/oldest product dates.

## `includeContacts` (type: `boolean`):

Scans the homepage plus the contact/about pages.

## `maxResults` (type: `integer`):

Process only the first N unique domains. 0 = no limit.

## `maxConcurrency` (type: `integer`):

How many stores are processed in parallel. Leave empty for automatic (scales with the run memory: 512 MB → 12).

## `requestTimeoutSecs` (type: `integer`):

Maximum time for each request.

## Actor input object example

```json
{
  "stores": [
    "allbirds.com",
    "gymshark.com",
    "glossier.com"
  ],
  "includeCatalogStats": true,
  "includeContacts": true,
  "maxResults": 0,
  "requestTimeoutSecs": 15
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `apps` (type: `string`):

No description

## `catalog` (type: `string`):

No description

## `contacts` (type: `string`):

No description

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

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

// Run the Actor and wait for it to finish
const run = await client.actor("itzcloud/shopify-intel").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",
        "gymshark.com",
        "glossier.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("itzcloud/shopify-intel").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",
    "gymshark.com",
    "glossier.com"
  ]
}' |
apify call itzcloud/shopify-intel --silent --output-dataset

```

## MCP server setup

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

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/9Zx1YR3C66QlTsTCF/builds/IcJNqiuN5MJUCuC53/openapi.json