# Shopify Store Detector: Theme, Apps & Store Checker (`tiktop/shopify-store-detector`) Actor

Check if any website runs on Shopify. Bulk domains in; get the myshopify domain, theme name and version, installed Shopify apps, currency, country, email provider and the full tech stack. No login, no proxy.

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

## Pricing

from $1.50 / 1,000 store checkeds

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

Check whether a website runs on Shopify, in bulk. You give it a list of domains, and for each Shopify store it returns the **myshopify.com domain**, the **theme** (name, base theme such as Dawn or Prestige, and version), **Shopify apps** it can see, the storefront **currency, country and language**, the **email provider**, and the site's whole **tech stack** (payments, analytics, marketing, CDN). Output comes as clean JSON, CSV or Excel.

**Price: $2.00 per 1,000 websites checked.** You aren't charged for sites that fail to load or block the visit. Apify's free plan ($5 monthly credit) covers about 2,500 websites a month.

[![Shopify Store Detector output: Shopify yes/no, theme, theme version, currency and apps per store](https://raw.githubusercontent.com/TikTop-Data/apify-store-assets/main/images/shopify-store-detector-output.png)](https://console.apify.com/actors/arEV051f3oozO6xeq)

### Questions it answers

- Is this website a Shopify store?
- What Shopify theme (and version) does this store use?
- Which Shopify apps does this store run?
- What is this store's myshopify.com domain, currency and country?

### Who uses this

- 🛍️ **Shopify app and agency lead generation:** filter a domain list down to the Shopify stores, then segment them by theme, apps or country.
- 🎨 **Theme developers:** see which stores use Dawn, Prestige, Impulse or a custom theme, and which version.
- 🔍 **Competitive research:** check which payment, review, subscription and email tools competing stores use.
- 📊 **Ecommerce market research:** measure how much of a niche runs on Shopify versus WooCommerce, BigCommerce or Magento. The full tech stack is included for every site.

### What you get per website

| Field | Example | Notes |
|---|---|---|
| `isShopify` | `true` | Shopify fingerprint, the `Shopify.shop` global or Shopify CDN assets |
| `myshopifyDomain` | `deathwishcoffee.myshopify.com` | The store's permanent Shopify handle |
| `themeName` / `themeBase` / `themeVersion` | `deathwish-shopify-20/production` / `Dawn` / `10.0.0` | `themeBase` is the theme the store's theme is built on |
| `themeStoreId` | `887` (Dawn) | Theme Store ID when the store reports one |
| `currency`, `country`, `locale` | `USD`, `US`, `en` | As the storefront presents itself to the visitor |
| `shopifyApps` | `["Afterpay", "Klaviyo", "Rebuy"]` | Storefront apps found in the page: Shopify-only apps plus reviews, email/SMS, chat, loyalty, upsell, search and similar tools |
| `emailProvider` | `Google Workspace` | Read from public MX records |
| `technologyNames`, `categories`, `technologies` | | Full stack from 7,600+ technology fingerprints |

### How to use the Shopify Store Detector

1. Click **Try for free** (a free Apify account is enough).
2. Paste your domains, one per line. `example.com` works.
3. Click **Start**. Each site takes 1–3 seconds.
4. Filter the results by `isShopify`, `themeBase` or `shopifyApps`, then download them as JSON, CSV or Excel, or send them to Google Sheets or your CRM through the API.

### Input

| Field | Default | What it does |
|---|---|---|
| `urls` | required | Domains or URLs, one per line. `example.com` works. |
| `checkDns` | `true` | Look up DNS records (email provider, verified SaaS tools). |
| `minConfidence` | `50` | Hide weak detections. `0` shows everything. |
| `categoryFilter` | empty | Limit `technologies` to some categories, e.g. `Payment processors`, `Reviews`. Shopify fields are always returned. |
| `includeEvidence` | `true` | Show which signal triggered each detection. |
| `maxConcurrency` | `20` | Sites fetched in parallel. |
| `requestTimeoutSecs` | `30` | Per-site timeout. |
| `proxyConfiguration` | off | Optional proxy for sites that return HTTP 403. |

Example (the input behind the table above):

```json
{ "urls": ["allbirds.com", "gymshark.com", "deathwishcoffee.com", "bombas.com", "ruggable.com", "kyliecosmetics.com", "apify.com"] }
```

### Output

A real row from that run, shortened (the `technologies` detail is left out here):

```json
{
  "inputUrl": "deathwishcoffee.com",
  "url": "https://www.deathwishcoffee.com/",
  "domain": "deathwishcoffee.com",
  "httpStatus": 200,
  "title": "#1 Organic and #1 Fair Trade Coffee – Death Wish Coffee",
  "isShopify": true,
  "myshopifyDomain": "deathwishcoffee.myshopify.com",
  "themeName": "deathwish-shopify-20/production",
  "themeBase": "Dawn",
  "themeVersion": "10.0.0",
  "themeStoreId": null,
  "currency": "USD",
  "country": "US",
  "locale": "en",
  "shopifyApps": ["Afterpay", "HubSpot", "Klaviyo", "Rebuy", "..."],
  "shopifySignals": ["fingerprint", "Shopify.shop global", "Shopify CDN assets"],
  "emailProvider": null,
  "technologyCount": 21,
  "technologyNames": ["Afterpay", "Anthropic", "Apple Pay", "Cart Functionality", "..."],
  "categories": {
    "Payment processors": ["Afterpay", "Apple Pay", "Ordergroove", "PayPal", "..."],
    "Buy now pay later": ["Afterpay"],
    "Artificial Intelligence": ["Anthropic"],
    "Ecommerce": ["Cart Functionality", "Shopify"]
  },
  "error": null,
  "scannedAt": "2026-10-06T11:37:11.987Z"
}
```

Non-Shopify sites get `isShopify: false` plus their tech stack, so the same run also shows you who uses WooCommerce, Magento or BigCommerce.

### Example tasks

Ready-made inputs you can open and run:

- [Is this website a Shopify store? Bulk check](https://apify.com/tiktop/shopify-store-detector/examples/is-this-site-shopify-bulk-check)
- [What Shopify theme is this store using?](https://apify.com/tiktop/shopify-store-detector/examples/shopify-theme-detector)
- [Which Shopify apps does this store use?](https://apify.com/tiktop/shopify-store-detector/examples/shopify-apps-lookup)
- [Find the .myshopify.com domain of a store](https://apify.com/tiktop/shopify-store-detector/examples/myshopify-domain-finder)
- [Shopify store currency, country and language](https://apify.com/tiktop/shopify-store-detector/examples/shopify-store-currency-country)
- [Shopify theme and app change monitor](https://apify.com/tiktop/shopify-store-detector/examples/shopify-store-change-monitor)

### Check websites from another Actor (Google Maps leads, lead lists)

Have a list from Google Maps Scraper or any other Actor? Pick its dataset under **Websites from another Actor**. This Actor reads the `website` field (or the field you name, e.g. `url`, `domain` or `contact.website`) and checks every site. No copy and paste.

To run it automatically after every scrape, add an Actor-to-Actor integration to the source Actor or task with this input:

```json
{ "datasetId": "{{resource.defaultDatasetId}}", "datasetUrlField": "website" }
```

### Change alerts

Give the run a **Change alert name** (e.g. `clients-weekly`) and put it on an Apify schedule. Each row then gets `changeStatus` (`new`, `changed` or `unchanged`) and `changedFields`, compared with the previous run of the same name, so you see when a store changes theme, apps, currency or mail provider, or leaves Shopify. Turn on **Only new and changed sites** and each run's dataset is just the change report; unchanged sites are still checked and charged as usual. Add Apify's Slack or email integration to get the report delivered.

### How it works

It makes one plain HTTP request to each homepage, with no browser. From that page it reads the `Shopify.*` settings that every Shopify Online Store theme prints (shop handle, theme, currency, country, locale), then matches headers, scripts, cookies and HTML against the open-source Wappalyzer fingerprint database. When DNS checks are on, it also reads the domain's public DNS records. That's why it's fast and cheap, typically 1–3 seconds per site.

### Limitations

- **Headless Shopify stores** (Hydrogen or custom frontends) often don't print the theme settings. They're still detected as Shopify when Shopify assets show up in the page, but the theme, currency and myshopify fields stay empty.
- **Apps:** it only finds apps that show up in the homepage HTML. Apps that load later through JavaScript can be missed.
- **Currency and country** reflect the market the store shows to the visitor's location. Multi-market stores can show a different currency to visitors in other regions.
- It checks the URL you give (usually the homepage), not every page of the site.

### How much does it cost?

Pay per event:

- **Store checked:** $0.002 per website that loads successfully, whether or not it turns out to be Shopify ($2.00 per 1,000).
- **Actor start:** $0.00005 per GB of memory (default 2 GB = $0.0001 per run).
- Sites that fail, don't resolve, or return HTTP 4xx/5xx: free.

| Websites | Cost |
|---|---|
| 100 | about $0.20 |
| 1,000 | about $2 |
| 10,000 | about $20 |

Apify's free plan includes $5 of credit every month, enough for about 2,500 websites. Paid Apify plans get Store discounts of up to 25%. You can set a maximum cost per run, and the Actor stops cleanly when it reaches it.

### FAQ

**Is this legal?** It loads each public homepage once, as a browser would, and reads public DNS records. It collects facts about software, not personal data.

**Can I run it on a schedule or through the API?** Yes. Use Apify schedules, the API, or integrations (Zapier, Make, Google Sheets, webhooks).

**Why are the theme and currency empty for a store marked Shopify?** It's most likely a headless store (see Limitations). The Shopify detection itself still holds.

**I need every technology, not only Shopify.** Use [Website Tech Stack Detector](https://apify.com/tiktop/tech-stack-detector) ($1.50 per 1,000 sites).

### Related Actors

- [Website Tech Stack Detector](https://apify.com/tiktop/tech-stack-detector): 7,600+ technologies for any site, not only Shopify.
- [SEO Meta Tag & Schema Checker](https://apify.com/tiktop/seo-meta-checker): titles, meta tags and Product schema for the same stores.
- [Bulk URL Status & SSL Checker](https://apify.com/tiktop/url-status-ssl-checker): status codes, redirects and SSL expiry.

### License and credits

Technology fingerprints come from [enthec/webappanalyzer](https://github.com/enthec/webappanalyzer) (GPL-3.0). This Actor's source code is GPL-3.0 as well. It isn't affiliated with Shopify, Wappalyzer or BuiltWith.

# Actor input Schema

## `urls` (type: `array`):

Domains or URLs to scan, one per line. Bare domains like <code>example.com</code> are fine; <code>https://</code> is added automatically. The homepage (or the exact URL you give) is analysed. Or use "Websites from another Actor" below.

## `datasetId` (type: `string`):

Check the websites in another Actor run's results, e.g. Google Maps Scraper or any lead list. Pick the dataset here, or in an Actor-to-Actor integration set it to {{resource.defaultDatasetId}}. Its websites are added to the list above.

## `datasetUrlField` (type: `string`):

The dataset field that holds the website or URL, e.g. website (Google Maps Scraper), url or domain. Dot paths like contact.website work. If it is empty, website, url and domain are tried.

## `maxDatasetItems` (type: `integer`):

Read at most this many rows from that dataset.

## `monitorName` (type: `string`):

Name this list (e.g. "clients-weekly") to compare each run with the previous run of the same name. Every row then gets changeStatus (new, changed or unchanged) and changedFields. Best on an Apify schedule.

## `onlyChanges` (type: `boolean`):

Needs a change alert name. Unchanged sites are still checked and charged as usual, but left out of the results, so each run's dataset is your change report.

## `checkDns` (type: `boolean`):

Look up MX, TXT, NS and SOA records to detect the store's email provider (Google Workspace, Microsoft 365) and verified SaaS tools. Adds about 0.2 s per site.

## `minConfidence` (type: `integer`):

Hide detections below this confidence. 50 removes weak single-signal guesses. Use 0 to see everything.

## `categoryFilter` (type: `array`):

Optional. Return only technologies in these categories, e.g. <code>Ecommerce</code>, <code>CMS</code>, <code>Analytics</code>, <code>Marketing automation</code>, <code>Live chat</code>, <code>Payment processors</code>, <code>Email</code>. Case-insensitive. Leave empty for all.

## `includeEvidence` (type: `boolean`):

Add which signal triggered each detection (header, script URL, meta tag, cookie, DNS record...).

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

How many sites to fetch in parallel.

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

Give up on a site that takes longer than this to respond.

## `proxyConfiguration` (type: `object`):

Optional. Most sites don't need a proxy. Enable if many sites return HTTP 403.

## Actor input object example

```json
{
  "urls": [
    "allbirds.com",
    "gymshark.com",
    "apify.com"
  ],
  "datasetUrlField": "website",
  "maxDatasetItems": 10000,
  "onlyChanges": false,
  "checkDns": true,
  "minConfidence": 50,
  "includeEvidence": true,
  "maxConcurrency": 20,
  "requestTimeoutSecs": 30,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (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 = {
    "urls": [
        "allbirds.com",
        "gymshark.com",
        "apify.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("tiktop/shopify-store-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 = {
    "urls": [
        "allbirds.com",
        "gymshark.com",
        "apify.com",
    ],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("tiktop/shopify-store-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 '{
  "urls": [
    "allbirds.com",
    "gymshark.com",
    "apify.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call tiktop/shopify-store-detector --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tiktop/shopify-store-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/arEV051f3oozO6xeq/builds/MfkP5iWb26WHI24X7/openapi.json