# Shopify Store Audit & Tech-Stack Lead Scorer (`scrapebench/shopify-store-intel`) Actor

Audit any Shopify store — installed apps, theme, pricing & catalog signals, and tech-stack gaps. Bulk-score a prospect list and monitor stores for app installs/removals.

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

## Pricing

$0.01 / store audited

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Shopify Store Audit & Tech-Stack Lead Scorer

### Pain points

- You can't tell what apps, theme, or tech a Shopify store runs just by looking at it.
- Qualifying a list of Shopify prospects by hand — which ones lack your app's category — is slow.
- Checking back later to see if a store added or dropped an app means re-auditing manually.

### What we solve

- Audit any Shopify store's installed apps, theme, and pricing/catalog signals from its public storefront.
- Flags the tech-stack gaps (missing app categories) plus a lead-match score against your criteria.
- Bulk-score a whole prospect list in one run, export-ready for your CRM.
- Run on a schedule to get alerted when stores install/remove apps or ramp their catalog.

### Summary

Turn a list of Shopify store domains into qualified, scored leads. For each store you get the detected apps (reviews, email, search, upsell, loyalty, subscription, chat), theme, and catalog/pricing signals — plus the tech-stack GAPS (which app categories are missing) and a lead-match flag against your criteria. Run it on a schedule and it also reports what changed since last time (apps added/removed, product-count delta) — turning competitor and prospect monitoring into a set-and-forget task. Built for app vendors and agencies prospecting Shopify merchants.

### Who it's for

- Shopify app vendors prospecting merchants who lack their category
- Agencies doing Shopify lead-gen and tech-stack audits
- Competitive-intelligence and e-commerce analysts
- Sales teams enriching a list of Shopify domains

### How to use

Set the input, run the actor, and collect results from the run's dataset (export to JSON/CSV/Excel, or pull via the Apify API). Example input:

```json
{
  "domains": [
    "allbirds.com",
    "colourpop.com"
  ],
  "targetGaps": [
    "reviews"
  ],
  "compareToPrevious": true
}
```

See **Inputs** below for every available field.

### What you get

One row per record:

| Field | Description |
|---|---|
| `domain` | Store domain audited |
| `is_shopify` | Whether the domain is a confirmed Shopify store |
| `detected_apps` | Installed apps detected from the storefront ({name, category}) |
| `app_categories` | Categories of detected apps |
| `missing_categories` | App categories with NO detected app — the prospecting gaps |
| `matches_criteria` | True when all your target-gap categories are missing (a lead) |
| `has_reviews_app / has_search_app / …` | Per-category presence flags (reviews, email, search, upsell, loyalty, subscription, chat) |
| `theme_name` | Storefront theme name |
| `product_count` | Product count (caps at maxProductsPerStore) |
| `price_min / price_max` | Variant price range |
| `currency` | Store currency (ISO code) |
| `discount_rate` | Fraction of products with a compare-at markdown |
| `new_products_30d` | Products created in the last 30 days (catalog velocity) |
| `shopify_plus` | Best-effort Shopify Plus signal |
| `products_json_accessible` | Whether /products.json was readable (else counts via sitemap) |
| `apps_added / apps_removed` | Apps installed/removed since the previous run (monitoring) |
| `product_count_delta` | Product-count change since the previous run |
| `first_seen` | True on the first run for this domain |
| `source_url` | The store URL |

Sample:

```json
{
  "domain": "allbirds.com",
  "is_shopify": true,
  "detection_signals": [
    "cdn.shopify.com",
    "Shopify.theme"
  ],
  "shopify_plus": false,
  "theme_name": "Dawn",
  "detected_apps": [
    {
      "name": "Yotpo",
      "category": "reviews"
    },
    {
      "name": "Klaviyo",
      "category": "email"
    }
  ],
  "app_categories": [
    "email",
    "reviews"
  ],
  "has_reviews_app": true,
  "has_email_app": true,
  "has_search_app": false,
  "missing_categories": [
    "search",
    "upsell",
    "loyalty",
    "subscription",
    "chat"
  ],
  "matches_criteria": false,
  "product_count": 629,
  "price_min": 18.0,
  "price_max": 160.0,
  "currency": "USD",
  "discount_rate": 0.12,
  "new_products_30d": 7,
  "products_json_accessible": true,
  "first_seen": false,
  "apps_added": [
    "Klaviyo"
  ],
  "apps_removed": [],
  "product_count_delta": 12,
  "source_url": "https://allbirds.com/"
}
```

### Inputs

| Field | Required | Type | Default | Description |
|---|---|---|---|---|
| `domains` | yes | array | `["allbirds.com"]` | Shopify store domains or URLs to audit, e.g. 'allbirds.com'. Paste a list to bulk-audit a prospect list. We audit the domains you provide (we don't discover stores). |
| `targetGaps` | no | array | — | App categories that should be MISSING for a store to count as a lead — sets 'matches\_criteria'. E.g. a reviews-app vendor sets \['reviews']. Categories: reviews, email, search, upsell, loyalty, subscription, chat. |
| `includeProducts` | no | boolean | `false` | When off (default), return store signals only (fast, cheap — the lead-gen need). Turn on to also include the (slimmed) product catalog. |
| `compareToPrevious` | no | boolean | `true` | When on (default), diff each store against the previous run and report what changed — apps added/removed and product-count delta. Run on a schedule to track stores over time. |
| `maxProductsPerStore` | no | integer | `1000` | Cap on products sampled per store (bounds cost). Product count caps here for very large stores. |
| `proxyConfiguration` | no | object | `{"useApifyProxy": false}` | Optional, and off by default. Measured 2026-08-19 across 12 stores from inside an actor run: the platform's own IPs reached 27/27 store checks and Apify Proxy's datacenter pool matched them, while RESIDENTIAL was the only mode that lost a store. If a storefront refuses, the actor already retries it at the store's <handle>.myshopify.com origin, which is what actually recovers a refusal. Turn a proxy on only if that also fails. |

### Pricing (Pay Per Event)

You pay per result (`dataset-item`) — **no charge for empty runs**. Example: **1000 Shopify stores audited** at *$0.01/result* ≈ **$10.00**.

You're only charged for confirmed Shopify stores — non-Shopify or unreachable domains are free. Apify platform usage (compute) is billed separately per your plan.

### Use cases

- App-vendor prospecting — find Shopify stores missing your app's category (e.g. no reviews app) and treat them as warm leads.
- Agency lead-gen — bulk-audit a prospect list, score by tech-stack gaps and store size, and export to your CRM.
- Competitor monitoring — run weekly to catch when stores install or remove apps, or ramp their catalog.
- Domain enrichment — add apps, theme, and catalog signals to stores you already have.

### Why this actor

- Reads the public storefront — no app install and no merchant permission needed.
- Detects apps + theme AND flags the gaps (missing categories) for warm-lead scoring.
- Bulk-score a whole domain list in one run; pay per store (non-Shopify domains are free).

### Limitations & updates

Storefront (public) data only — never returns real inventory counts, sales, revenue, orders, traffic, or customers (those are Admin-API-only). It audits the domains you provide; it does not discover stores across Shopify. Some stores disable /products.json (counts fall back to the sitemap). App detection is best-effort from storefront markers and is kept current via the self-healer. Some stores refuse their custom domain — usually a CDN or WAF in front of it, not Shopify. Those are retried automatically at the store's <handle>.myshopify.com origin, which recovered every refused store in our 2026-08-19 measurement; a store that refuses both doors is reported as unknown (is\_shopify null with a fetch\_error), never as not-Shopify.

### FAQ

**How do you detect a store's apps?**

From public storefront markers (scripts, theme, DOM signatures). No app install or merchant access is needed.

**What can't it see?**

Storefront-only data — never real inventory counts, sales, revenue, orders, or traffic (those are Admin-API-only).

**How am I charged?**

Pay-per-store audited. Non-Shopify or unreachable domains are free.

**Can it monitor changes over time?**

Yes — run on a schedule and it reports apps added/removed and the product-count delta since the last run.

**How accurate is app detection?**

Best-effort from storefront markers, kept current via our self-healer; some apps load server-side and can be missed.

**Some stores won't load?**

A few sit behind a CDN or WAF that refuses the custom domain — CloudFront and Vercel in our tests, not always Cloudflare. The actor automatically retries those at the store's <handle>.myshopify.com origin, which recovered every refused store we measured on 2026-08-19. No toggle, and no proxy needed.

### Which actor to choose

Part of the same Shopify suite — pick the one that fits your goal:

- **Shopify Price & Stock Change Tracker** — You want to monitor a Shopify store over time — price moves, back-in/out-of-stock flips, products added or removed.
- **Shopify Store Audit & Tech-Stack Lead Scorer** *(this actor)* — You want to audit or lead-score a Shopify store — installed apps, theme, and tech-stack gaps.

### Guides & use cases

Written up on **[scrapebench.dev](https://scrapebench.dev)** — the bench that runs and verifies this actor against the live source every night:

- **How-to:** [How to run Shopify Store Audit & Tech-Stack Lead Scorer](https://scrapebench.dev/guides/how-to-shopify-store-intel/)
- **Use case:** [Audit a Competitor's Shopify Tech Stack](https://scrapebench.dev/use-cases/audit-competitor-shopify-tech-stack/)
- **Use case:** [Detect a Shopify Store's Apps & Theme](https://scrapebench.dev/use-cases/detect-shopify-apps-and-theme/)
- **Use case:** [Find Shopify Stores Missing a Reviews App](https://scrapebench.dev/use-cases/find-shopify-stores-missing-reviews-app/)

More actors, coverage and nightly verification results: **[scrapebench.dev](https://scrapebench.dev)**

### Works with AI assistants (MCP)

Callable as an MCP tool, so Claude, Cursor, VS Code Copilot and other MCP clients can run it directly. Grab the config from the [MCP tab](https://apify.com/scrapebench/shopify-store-intel/api/mcp) on this page — Apify hosts the server and keeps that snippet current, and OAuth signs you in on first connect, so no API token goes in your config file.

Then just ask:

> "Audit allbirds.com — is it on Shopify, which apps and theme does it run, and what is it missing?"

One domain is the quickest check; pass a list of domains to score a whole prospect list in a single call. Runs started this way bill exactly like any other run.

# Actor input Schema

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

Shopify store domains or URLs to audit, e.g. 'allbirds.com'. Paste a list to bulk-audit a prospect list. We audit the domains you provide (we don't discover stores).

## `targetGaps` (type: `array`):

App categories that should be MISSING for a store to count as a lead — sets 'matches\_criteria'. E.g. a reviews-app vendor sets \['reviews']. Categories: reviews, email, search, upsell, loyalty, subscription, chat.

## `includeProducts` (type: `boolean`):

When off (default), return store signals only (fast, cheap — the lead-gen need). Turn on to also include the (slimmed) product catalog.

## `compareToPrevious` (type: `boolean`):

When on (default), diff each store against the previous run and report what changed — apps added/removed and product-count delta. Run on a schedule to track stores over time.

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

Cap on products sampled per store (bounds cost). Product count caps here for very large stores.

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

Optional, and off by default. Measured 2026-08-19 across 12 stores from inside an actor run: the platform's own IPs reached 27/27 store checks and Apify Proxy's datacenter pool matched them, while RESIDENTIAL was the only mode that lost a store. If a storefront refuses, the actor already retries it at the store's <handle>.myshopify.com origin, which is what actually recovers a refusal. Turn a proxy on only if that also fails.

## Actor input object example

```json
{
  "domains": [
    "allbirds.com",
    "colourpop.com"
  ],
  "targetGaps": [
    "reviews"
  ],
  "includeProducts": false,
  "compareToPrevious": true,
  "maxProductsPerStore": 1000,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `audits` (type: `string`):

Per-store intelligence: detected apps, gap flags, pricing/catalog signals, and changes since the last run.

# 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"
    ]
};

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

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

```

## MCP server setup

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