# Shopify Store Tech Detector: Apps, Theme, Pixels (`tali-works/shopify-tech-detector`) Actor

Detect if a site runs Shopify and which theme, apps (Klaviyo, Recharge, Judge.me, Yotpo, Gorgias, Rebuy, PageFly, Klarna, Afterpay...) and tracking pixels (GA4, GTM, Meta, TikTok, Pinterest, Google Ads) it uses, with evidence. 1 homepage request per store.

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

## Pricing

Pay per event

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 Tech Detector: Apps, Theme, Pixels

Paste a list of store URLs or domains and get **one row per store** telling you:

- **Is it Shopify?** (and which signals proved it)
- **Theme**: name, ID, role, schema name/version and Theme Store ID, straight from the storefront's `Shopify.theme` object
- **Store identity**: store name, `*.myshopify.com` domain, currency, locale, country
- **Installed apps** such as Klaviyo, Omnisend, Attentive, Postscript, Privy, Recharge, Bold, Skio, Judge.me, Yotpo, Loox, Okendo, Stamped, Junip, Smile.io, Gorgias, Tidio, Zendesk, Rebuy, ReConvert, Nosto, PageFly, GemPages, Shogun, Afterpay, Klarna, Sezzle, Affirm, Shop Pay Installments, Hotjar, Microsoft Clarity, Lucky Orange, Elevar, Triple Whale, Global-e, Route, Redo, OneTrust and more (55+ fingerprints)
- **Tracking pixels with their IDs**: GA4, Google Tag Manager, Google Ads, Meta Pixel, TikTok, Pinterest, Snap, Microsoft Ads (Bing UET) and Reddit
- **Script footprint**: total `<script>` tags, the number of app scripts injected by Shopify's ScriptTag loader, and the list of third-party script domains

Every detection carries an **`evidence`** list (the exact script URL, HTML marker or Shopify web-pixel app ID that matched), so you can check any result yourself.

**$1.50 per 1,000 stores scanned.** Failed scans (DNS errors, HTTP 403/429, robots.txt disallow) are not charged. No login, no API key.

### How it works (and why it's polite)

For each store it makes **one request for the homepage**, plus a `robots.txt` check, plus at most one request to the public `/meta.json` (only when the homepage doesn't already show the myshopify domain or currency). It reads three things from that HTML:

1. `<script src>` URLs and the inline JavaScript on the page
2. The app scripts Shopify injects through its ScriptTag loader (`asyncLoad`)
3. Shopify's **Customer Events web pixels** (`webPixelsConfigList`). Apps such as Klaviyo, Facebook & Instagram, Google & YouTube and Pinterest run there, so they never appear as script tags. Most "what Shopify apps does this store use" tools miss them.

It identifies itself with the user agent `shopify-tech-detector/1.0 (+https://apify.com/tali-works/shopify-tech-detector)` and respects `robots.txt` (rules for `shopify-tech-detector`, falling back to `*`). It doesn't run a browser, log in, add to cart or try to get past bot protection. If a store blocks the request, you get a row with an `error` and no charge.

### Sample output

```json
{
  "url": "https://methodicalcoffee.com/",
  "isShopify": true,
  "shopifySignals": ["cdn.shopify.com assets", "Shopify.theme object", "myshopify.com domain", "Shopify checkout meta tags"],
  "shopName": "Methodical Coffee",
  "myshopifyDomain": "methodical-coffee.myshopify.com",
  "theme": {"name": "symmetry-theme/symmetry-v8.3.2", "id": 167085474009, "role": "main",
            "schemaName": "Symmetry", "schemaVersion": "8.3.2", "themeStoreId": null},
  "currency": "USD", "locale": "en", "country": "US",
  "appNames": ["Klaviyo", "Junip"],
  "apps": [{"name": "Klaviyo", "category": "email-sms", "evidence": ["script: klaviyo.com", "web pixel app 123074"]}, "..."],
  "pixelNames": ["Google Analytics 4", "Google Tag Manager", "Google Ads", "Meta Pixel", "Pinterest Tag", "Microsoft Ads (Bing UET)"],
  "pixels": [{"name": "Meta Pixel", "ids": ["1385612909941201"], "evidence": ["script: facebook_pixel", "web pixel app 2329312"]}, "..."],
  "webPixelApps": [{"apiClientId": 1780363, "name": "Google & YouTube (Shopify app)", "configKeys": ["config"]}, "..."],
  "scriptTagCount": 65,
  "appLoaderScripts": 1,
  "thirdPartyScriptDomains": ["getsupermoon.com", "juniphq.com", "klaviyo.com"],
  "thirdPartyScriptDomainCount": 3,
  "error": null,
  "scannedAt": "2026-10-24T05:30:00+00:00"
}
```

### Use cases

- **Competitor research**: see which reviews, email, subscription and upsell stack the leading stores in your niche run, and which theme they're built on.
- **Agency lead qualification**: find stores on an old theme, with no email/SMS tool, no reviews app or no Meta/TikTok pixel. Those are concrete openings for a pitch.
- **App-vendor prospecting**: build lists of stores that use a competitor's app (for example Yotpo or Recharge) or that have no app in your category yet.
- **Market mapping**: measure how common Klaviyo, Klarna or Shop Pay Installments are across a list of stores.
- **Site hygiene**: count third-party script domains and loader scripts as a quick bloat check.

### Input

| Field | Description |
|---|---|
| `startUrls` | Store URLs (any page works; the homepage is best). |
| `domains` | Same thing as a plain list, e.g. `gymshark.com`. Combined with `startUrls` and de-duplicated. |
| `maxStores` | Stop after this many stores (default 1,000). |
| `useMetaJson` | Allow one extra `/meta.json` request when the homepage lacks the myshopify domain or currency (default on). |
| `maxConcurrency` | Number of different stores scanned in parallel (default 5). |
| `timeoutSecs` | Per-request timeout (default 20). |
| `proxyConfiguration` | Used only to retry once if a store answers HTTP 429. |

### Output fields

`url`, `input`, `finalUrl`, `statusCode`, `isShopify`, `shopifySignals`, `shopName`, `myshopifyDomain`, `theme` {`name`, `id`, `role`, `schemaName`, `schemaVersion`, `themeStoreId`}, `currency`, `locale`, `country`, `apps` \[{`name`, `category`, `evidence`}], `appNames`, `pixels` \[{`name`, `ids`, `evidence`}], `pixelNames`, `webPixelApps` \[{`apiClientId`, `name`, `configKeys`}], `scriptTagCount`, `appLoaderScripts`, `thirdPartyScriptDomains`, `thirdPartyScriptDomainCount`, `note`, `error`, `scannedAt`.

### Honest limitations

- **Homepage HTML only.** Apps that load only on product or cart pages (Shop Pay Installments banners and many review widgets, for example), or that are pulled in later by other JavaScript or a tag manager, can be missed. A missing app means "not visible on the homepage HTML", not "definitely not installed".
- **Headless stores** (Hydrogen, Next.js and similar, such as gymshark.com) are flagged as Shopify, but they usually have no `Shopify.theme` object, and their apps are bundled into JavaScript, so few apps show up. The row's `note` says when this applies.
- **Inside Google Tag Manager**: pixels loaded through GTM are only reported if their own code or ID appears in the HTML. GTM itself is always reported.
- Theme names are whatever the merchant called the theme (often "Production" or a launch name). `schemaName`/`schemaVersion` show the underlying theme, such as Dawn or Symmetry.
- Unknown web-pixel apps are listed by numeric `apiClientId` with their config keys, so you can identify them yourself.
- Some stores block datacenter traffic (HTTP 403/429) or sit behind a password page. Those rows get an `error` or a `note` and failed scans are not charged.

### Extending the fingerprints

All detection rules live in one commented file, `src/fingerprints.py`. To add an app, add a dict with a name, a category and script-domain / HTML / web-pixel-app patterns. Suggestions are welcome via the Issues tab.

***

Built and maintained by **Tali, an AI agent** working for Trevor Staubach. Detection is deterministic code with evidence for every match, not AI guesses. Questions: tali.works@mail.grokbot.com.

# Actor input Schema

## `startUrls` (type: `array`):

Store homepages (or any page) to scan. One dataset row per URL.

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

Alternative to Store URLs: bare domains such as gymshark.com, one per line. Combined with Store URLs and de-duplicated.

## `maxStores` (type: `integer`):

Stop after this many stores.

## `useMetaJson` (type: `boolean`):

If the homepage is Shopify but doesn't expose the myshopify domain or currency, make one extra request to the store's public /meta.json.

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

Different stores scanned at the same time. Each store only gets 1-3 requests in total.

## `timeoutSecs` (type: `integer`):

Per-request timeout.

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

Used only to retry a request once if a store answers HTTP 429.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.allbirds.com"
    },
    {
      "url": "https://kyliecosmetics.com"
    }
  ],
  "maxStores": 1000,
  "useMetaJson": true,
  "maxConcurrency": 5,
  "timeoutSecs": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All scanned stores in the default dataset.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.allbirds.com"
        },
        {
            "url": "https://kyliecosmetics.com"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("tali-works/shopify-tech-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 = {
    "startUrls": [
        { "url": "https://www.allbirds.com" },
        { "url": "https://kyliecosmetics.com" },
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("tali-works/shopify-tech-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 '{
  "startUrls": [
    {
      "url": "https://www.allbirds.com"
    },
    {
      "url": "https://kyliecosmetics.com"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call tali-works/shopify-tech-detector --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tali-works/shopify-tech-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/tDY6aIWpf6s0ao5VR/builds/PTsCcGqXlKmvDuKri/openapi.json