# Shopify App & Theme Detector — Bulk Store Checker (`insanedev/shopify-app-detector`) Actor

Find which apps, theme and pixels any Shopify store uses. Paste 1 or 100,000 domains: most answers come instantly from our index of 780k+ Shopify stores, the rest are read live. Is it Shopify? Free. Pay per store detected.

- **URL**: https://apify.com/insanedev/shopify-app-detector.md
- **Developed by:** [Insane Developer](https://apify.com/insanedev) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 shopify store detecteds

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

### What is Shopify App & Theme Detector?

**Shopify App & Theme Detector** checks a list of websites in bulk and tells you, for each one, **whether it is a
Shopify store, which theme it runs and which Shopify apps it uses**: email and SMS, reviews, loyalty, subscriptions,
upsells, support chat, analytics and ads. Paste 1 or 100,000 domains and get one row per site.

You pay **$2 per 1,000 Shopify stores** we detect. Sites that aren't Shopify, are blocked or down cost nothing, and
**your account's first 25 Shopify stores are free**. To try it, keep the three example domains in the input and click
**Start**.

### Who uses it?

- Shopify app makers and agencies qualify a lead list: which stores already run a competitor's app, and which run
  none in that category.
- Theme developers and designers see which theme each store runs.
- Sales teams clean a CRM export down to the Shopify stores before outreach.
- Analysts and investors measure how widely an app is used across a set of stores.

### What can this Shopify detector do?

- **Is it Shopify?** Check a lead list, a CRM export or the output of another Actor, and keep only Shopify stores.
  Non-Shopify domains are free, so a bulk check of mixed lists costs only the stores you keep.
- **Shopify app detector.** Every app that adds a theme app block, our own fingerprints for 99 common apps, and
  (with Full technology scan) about 3,000 more apps and widgets from open fingerprint lists.
- **Shopify theme detector.** The theme's name as the store reports it (`Dawn`, `Impulse`, `Prestige` or a custom one).
- **Payment methods and pixels.** Shop Pay, PayPal, Klarna, Afterpay and others, and how many tracking pixels the
  store loads.
- **Store context from our index.** Store name, country, currency, catalogue size, `*.myshopify.com` host and
  whether the store is among a country's most visited sites.
- **Fast on big lists.** We keep our own index of 780,000+ Shopify stores. A store we read in the last 7 days is
  answered instantly, the rest are read live.
- **API, schedules and integrations.** Run it from the API, Python or JavaScript, on a schedule, from Make, Zapier
  or n8n, or from an AI agent through the Apify MCP server.

### What data does it return?

| Field                                          | Example                                                                |
| ---------------------------------------------- | ---------------------------------------------------------------------- |
| `domain`                                       | `allbirds.com`                                                         |
| `isShopify`                                    | `true`                                                                 |
| `status`                                       | `ok`, `notShopify`, `blocked`, `unreachable`, `notFound`, `notChecked` |
| `theme`                                        | `Dawn`                                                                 |
| `apps`                                         | `["Klaviyo", "Yotpo", "Recharge"]`                                     |
| `appsDetailed`                                 | `[{"name": "Klaviyo", "category": "Email & SMS"}, …]`                  |
| `appsCount`                                    | `3`                                                                    |
| `technologies`                                 | `[{"name": "Cloudflare", "categories": ["CDN"], "version": null}, …]`  |
| `pixelsCount`                                  | `9` (live reads only)                                                  |
| `paymentMethods`                               | `["Shop Pay", "PayPal", "Klarna"]` (live reads only)                   |
| `name`, `country`, `currency`, `productsCount` | from our index                                                         |
| `popularityTop`, `popularityScope`             | the store is among the top N sites of a country (Chrome UX Report)     |
| `myshopifyDomain`                              | `allbirds.myshopify.com`                                               |
| `source`, `readAt`                             | `index` + the date we read the store, or `live` + today                |

A real row from a run on 26 October 2026, with `appsDetailed` cut to two entries:

```json
{
    "domain": "thewoobles.com",
    "isShopify": true,
    "status": "ok",
    "theme": "Woobles",
    "apps": [
        "Klaviyo",
        "Postscript",
        "Judge.me",
        "Intelligems",
        "Elevar",
        "Blockify Fraud Filter",
        "Black Crow Ai That Delivers",
        "Inbox",
        "Epa Easy Product Addons",
        "PayPal messaging"
    ],
    "appsDetailed": [
        { "name": "Klaviyo", "category": "Email & SMS" },
        { "name": "Postscript", "category": "Email & SMS" }
    ],
    "appsCount": 10,
    "pixelsCount": 14,
    "paymentMethods": ["PayPal", "Apple Pay", "Shop Pay", "Amazon Pay"],
    "name": "The Woobles",
    "country": "US",
    "currency": "USD",
    "productsCount": 797,
    "popularityTop": 10000,
    "popularityScope": "US",
    "myshopifyDomain": "the-woobles.myshopify.com",
    "source": "live",
    "readAt": "2026-10-26"
}
```

You can download the results as JSON, CSV, Excel or HTML, or read them from the API.

### How to detect Shopify apps and themes in bulk

1. Click **Try for free** and sign in to Apify (the free plan is enough for a first run).
2. Paste your domains or URLs into **Store domains or URLs**, one per line: bare domains, homepage URLs, product links
   and `*.myshopify.com` hosts all work.
3. Click **Start**. In our test, 250 mixed domains took about 3 minutes.
4. Open the **Output** tab, filter by `status` or `apps`, and export.

### How much does it cost to check Shopify stores?

You pay only for Shopify stores whose apps and theme we return (`status: ok`), less on higher Apify plans. Everything
else is in the results for free.

| List                                    | Price |
| --------------------------------------- | ----- |
| First 25 Shopify stores on your account | free  |
| 1,000 domains, 400 of them Shopify      | $0.80 |
| 1,000 Shopify stores                    | $2    |
| 10,000 Shopify stores                   | $20   |

The free Apify plan's monthly credit covers about 2,500 Shopify stores.

### How does it compare?

We ran the same 30 domains (20 Shopify stores, 10 big non-Shopify sites) through this Actor and two other Shopify
detectors in Apify Store on 26 October 2026.

|                              | This Actor | Detector A | Detector B |
| ---------------------------- | ---------- | ---------- | ---------- |
| Shopify stores found         | 20/20      | 20/20      | 20/20      |
| Sites wrongly called Shopify | 0          | 0          | 0          |
| Apps found per store         | 7.8        | 2.2        | 2.1        |
| Theme name right             | 20/20      | 20/20      | 7/20       |
| Price for this list          | $0.04      | $0.054     | $0.20      |
| Non-Shopify sites billed     | no         | yes        | no         |

The other two give things we don't: one returns contacts and change alerts, the other lead criteria. For contacts, see
[Shopify Store Leads](https://apify.com/insanedev/shopify-store-list) below.

### Input options

- **Store domains or URLs**: up to 100,000 per run.
- **Answer from our index when it read the store recently** (on): off reads every store live.
- **Use index reads up to this old**: 7 days by default. Raise it for faster runs on big lists.
- **Read stores live when our index has no recent read** (on): off gives instant, index-only answers.
- **Also open one product page and the cart in live reads** (on): review and subscription widgets often load only on
  product pages, PayPal messaging and checkout wallets on the cart.
- **Full technology scan in live reads** (off): also matches the open fingerprint lists, so you get about 3,000 more
  apps and widgets and `technologies` (CDN, JavaScript libraries and their versions, analytics, servers). Live reads
  get about 1.6 times slower.
- **Show what matched each technology** (off): adds `evidence` to each technology, where it matched (script URL,
  HTML, meta tag, header, cookie, app block) and the matched text, so you can check a detection.

#### Example inputs

Fastest check, answers from our index only (stores it hasn't read in the last 7 days come back `notChecked`, free):

```json
{ "domains": ["allbirds.com", "gymshark.com", "example.com"], "liveCheck": false }
```

Every store read today, with all technologies and what matched them:

```json
{
    "domains": ["allbirds.com", "gymshark.com"],
    "fastFromIndex": false,
    "fullTechnologyScan": true,
    "technologyEvidence": true
}
```

### How it works and its limits

Apps are detected from what the storefront loads: script URLs, inline code, meta tags, headers, cookies and theme app
blocks. A store we read in the last 7 days answers from our index; any other store is read live (homepage, and by
default one product page and the cart). If a store blocks the live read, our last read of it (up to 45 days old)
answers instead, and `readAt` tells you the date.

- An app that leaves no trace on the storefront (back-office apps, most ERP and inventory tools) can't be seen from
  outside, by this Actor or anyone else.
- The detector covers Shopify only. For other sites it says they aren't Shopify; it doesn't name WordPress, Wix or
  other platforms.
- Stores read live go at about 2,000 domains per hour. A list of mostly unknown or long-tail domains takes longer
  than one our index already knows.

### FAQ

#### How do I check if a website uses Shopify?

Paste the domain and run. `isShopify` is `true` for Shopify stores, including headless ones that keep Shopify's
endpoints on the same host. Non-Shopify domains come back with `status: notShopify` and are free.

#### Which Shopify apps can it detect?

Every app that adds a theme app block to the store, named after its App Store handle, plus 99 common apps from our own
fingerprints (Klaviyo, Yotpo, Judge.me, Recharge, Gorgias, Okendo and others). Turn on **Full technology scan** for
about 3,000 more apps and widgets.

#### How fresh are the answers?

At most 7 days old by default, and `readAt` shows the date of each read. Lower **Use index reads up to this old**
(1 day at least) or turn off **Answer from our index when it read the store recently** to read every store today.

#### Can it find Shopify stores for me?

No, it checks the domains you give it. To find stores by app, theme, country or niche, with e-mails and social
profiles, use [Shopify Store Leads](https://apify.com/insanedev/shopify-store-list).

#### Why is a store `blocked` or `unreachable`?

Some stores sit behind a bot challenge or a geo block, and some are down. We never bypass a challenge. Those rows are
free, and when our index read the store before, that read answers instead.

#### Can I use it from code or an AI agent?

Yes. Use the API tab for JavaScript, Python or cURL, or connect the Apify MCP server so Claude, Cursor or another
agent can call it.

#### Is it legal to detect a store's apps?

The Actor reads only public storefront pages, the same pages any visitor's browser loads, and returns no personal
data. Check the rules that apply to how you use the results.

### Feedback and support

If a run returns a wrong app, a missed one or an error, open an issue in the **Issues** tab with the run ID and the
domain, and we'll answer there.

### Related Actors

- [Shopify Store Leads](https://apify.com/insanedev/shopify-store-list): the reverse question. Find Shopify stores by
  app, theme, country and niche, with e-mails, phones and social profiles. Same index, same app detection.
- [Shopify & WooCommerce Price Tracker](https://apify.com/insanedev/shopify-price-tracker): every product, price and
  stock change of the stores you follow.

### Fingerprint sources

The open fingerprints come from these lists, merged and filtered for weak or slow patterns:
[webappanalyzer](https://github.com/enthec/webappanalyzer) (the open Wappalyzer list, GPL-3.0),
[nuclei-templates](https://github.com/projectdiscovery/nuclei-templates) (MIT),
[FingerprintHub](https://github.com/0x727/FingerprintHub) (MIT), [WhatWeb](https://github.com/urbanadventurer/WhatWeb)
(GPL-2.0) and [Retire.js](https://github.com/RetireJS/retire.js) (Apache-2.0). This Actor isn't affiliated with
Shopify or Wappalyzer.

# Changelog

This Actor's version history is a separate document: https://apify.com/insanedev/shopify-app-detector/changelog.md

# Actor input Schema

## `domains` (type: `array`):

Domains, homepage URLs or product links, one per line (allbirds.com, https://www.allbirds.com/products/…, brand.myshopify.com). Up to 100,000 per run (live reads run at about 2,000 domains per hour); duplicates are checked once.

## `fastFromIndex` (type: `boolean`):

On (default): stores our index read in the last days (see below; popular stores are re-read weekly) are answered instantly from that read; all others are read live. Off: every store is read live, so apps are as of today, at about 2,000 domains per hour.

## `liveCheck` (type: `boolean`):

On: stores outside our index, or read longer ago than the age below, are read live. Off: only instant answers from the index; the other domains come back as "notChecked", free.

## `maxIndexAgeDays` (type: `integer`):

Our latest read of a store is used when it is at most this old. Raise it for faster runs on big lists (an app added since may be missing); lower it for fresher answers.

## `productPage` (type: `boolean`):

Review, subscription and upsell widgets often load only on product pages; PayPal messaging and checkout wallets on the cart. Two extra requests per store.

## `technologyEvidence` (type: `boolean`):

Adds an <code>evidence</code> field to each live-read technology: where it matched (script URL, HTML, meta tag, header, cookie, app block) and the matched text. Useful to check a detection.

## `fullTechnologyScan` (type: `boolean`):

Also matches the open fingerprint lists on each live-read homepage: about 3,000 more apps and widgets and 10,600 technologies (CDN, JavaScript libraries and versions, analytics). Off: our own app fingerprints and every theme app block, about 1.6x faster.

## Actor input object example

```json
{
  "domains": [
    "allbirds.com",
    "deathwishcoffee.com",
    "colourpop.com"
  ],
  "fastFromIndex": true,
  "liveCheck": true,
  "maxIndexAgeDays": 7,
  "productPage": true,
  "technologyEvidence": false,
  "fullTechnologyScan": false
}
```

# Actor output Schema

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

No description

## `summary` (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 = {
    "domains": [
        "allbirds.com",
        "deathwishcoffee.com",
        "colourpop.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("insanedev/shopify-app-detector").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 = { "domains": [
        "allbirds.com",
        "deathwishcoffee.com",
        "colourpop.com",
    ] }

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

```

## MCP server setup

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

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/0KA0OXgfka7RO8dAR/builds/999DO6TYOER1bLFki/openapi.json