# Shopify Theme & App Detector: Store Analyzer (Paused) (`reliable_tools/shopify-theme-app-detector`) Actor

PAUSED while we obtain written permission from Shopify: runs fetch no store data and charge no results, each store gets a free "paused" row. Once resumed it detects theme, apps, product count and prices of Shopify stores.

- **URL**: https://apify.com/reliable_tools/shopify-theme-app-detector.md
- **Developed by:** [Reliable Tools](https://apify.com/reliable_tools) (community)
- **Categories:** E-commerce, Lead generation, SEO 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 Theme Detector & App Detector: Store Analyzer for any Shopify store

> **Paused: store analysis is on hold.** We are asking Shopify for written permission before this Actor sends any further request to a store. Until then every run returns one free row per store with `status: "paused_pending_permission"`. No data is fetched and no result is charged. Only the Actor start fee that Apify bills on every run ($0.00005 per GB of run memory) still applies. The description below shows how the Actor works once it is resumed.

This Shopify theme detector and app detector tells you which theme a Shopify store runs and which apps it has installed. Give it a list of stores and you get one row per store: the theme, the installed apps, how big the catalog is, the price range, how many products were added in the last 30 days, and an optional AI label for niche, business model and audience. Everything is read from the store's public pages. Run it for one competitor or a few hundred leads, and export the results as JSON, CSV or Excel, or call it through the API.

We built it because qualifying Shopify stores by hand is slow. You open the site, view the source, guess the theme,
scroll the catalog, and repeat that a hundred times. This does it in seconds per store.

### Who uses it

- Agencies and freelancers looking for stores on a certain theme, or stores without a reviews or email app, to pitch.
- Shopify app developers checking which competitors' apps a market already uses.
- Brands keeping an eye on competitors' stack, catalog size and how often they launch products.
- Dropshippers and product researchers who want to see price points and new-product activity across many stores.
- Investors screening lists of DTC brands by niche, size and activity.

### What you get for each store

| Field | Example |
|---|---|
| Name, country, currency | Allbirds, US, USD |
| Theme | base theme `Dawn`, version `15.2.0`, and whether it is a Theme Store theme or custom-built |
| Installed apps | Klaviyo, Judge.me, Yotpo, Recharge, Gorgias, Attentive, Afterpay, Meta Pixel, TikTok Pixel and 40+ more |
| Catalog | published products and collections, lowest, median and highest price, top vendors, top product types |
| Activity | date of the newest product and how many products were added in the last 30 days |
| Shipping | number of countries the store ships to |
| Niche label | niche (22 categories), business model (own brand, multi-brand retailer, print-on-demand, digital products, general dropshipping) and main audience, each with a confidence score from 0 to 1 |
| Sample products | 10 products with title, URL, price, type and vendor |

If a site isn't a Shopify store you get `isShopify: false`. Some big brands put a custom front end on top of Shopify
that hides the store data; those come back as `storefront: "headless"`. Neither case is charged. You only pay for
stores that return data.

### How to run it

1. Paste store URLs or domains into **Store URLs or domains**, for example `allbirds.com` or `https://www.gymshark.com`.
2. Set **Max products to read per store** if you want more or less than 250. Set it to 0 to skip the catalog.
3. Leave **AI niche, business model and audience label** switched on if you want the niche label.
4. Start the run. Export the results as JSON, CSV or Excel, or pull them through the API, Make, Zapier or n8n.

### Example output

```json
{
  "input": "colourpop.com",
  "isShopify": true,
  "storefront": "online_store",
  "shopName": "ColourPop",
  "country": "US",
  "currency": "USD",
  "theme": { "baseTheme": "Colourpop", "isCustomTheme": true },
  "apps": ["Attentive", "Elevar", "Gorgias", "Junip", "Klarna", "Klaviyo"],
  "publishedProducts": 1064,
  "catalog": { "priceMin": 1.0, "priceMedian": 12.0, "priceMax": 159.0, "productsAddedLast30Days": 2 },
  "ai": { "niche": "Health & Beauty", "nicheConfidence": 1.0, "businessModel": "own_brand", "audience": "women" }
}
```

### How to use the Shopify theme detector via API

You can run the Shopify theme detector in the Apify Console, or call it from your own code through the Apify API. The **API** tab of this Actor has ready-to-copy examples for the JavaScript and Python API clients, the Apify CLI, plain HTTP and the OpenAPI definition. To use it from an AI assistant or agent, connect the Apify MCP server and add this Actor as a tool.

Send the same JSON input you would fill in the form, for example a list of store domains such as `allbirds.com`, start a run, and read the results from the run's default dataset as JSON, CSV or Excel. You can also schedule runs in Apify.

### Pricing

You pay per event and there's no subscription. A store that returns data counts as one "store analyzed" event. If the
niche label is on, that store also counts as one "AI label" event. Stores that aren't Shopify, or that are headless,
cost nothing.

### Tips

- For a clean list, filter on `nicheConfidence >= 0.7`. Lower scores usually mean the store sells a mix of things.
- To find stores missing an app, filter the `apps` column. A store with no reviews app is an easy pitch for a reviews agency.
- `productsAddedLast30Days` is a quick way to see which stores are actively launching products.

### FAQ

**How does it access stores?** It reads three kinds of public storefront pages only: the homepage source, the public
store info and the public product catalog, the same pages a visitor's browser loads. It does not use any Shopify API,
never logs in, never touches carts, checkout or accounts, and does not download theme files. It identifies itself as
`ReliableToolsBot`, checks each store's robots.txt first and skips any page the store disallows (those rows come back
with `status: "blocked_by_robots_txt"` and are not charged). It waits at least one second between requests to the same
store, or longer if the store's robots.txt sets a crawl delay, and reads at most two stores at a time. If a store asks
for a crawl delay above 10 seconds, the catalog is skipped. If a store refuses automated access, the Actor stops for
that store and does not retry (`status: "refused_by_store"`, not charged). Stores that cannot be reached come back
with `status: "unreachable"` and are not charged. It does not target personal data. You are
responsible for how you use the results.

**Why are some stores marked headless?** They run their own front end on top of Shopify, which doesn't expose the
public store data. You aren't charged for them.

**How accurate is the niche label?** Every label comes with a confidence score. A high score means the store clearly fits one
category. When a store sells several kinds of products, the score drops and tells you so.

**Can I read every product of a big store?** You can raise **Max products to read per store** up to 1,000. That is enough for reliable price ranges and activity stats.

**How do I find out what Shopify theme a store is using?** Put the store's domain into **Store URLs or domains** and read the `theme` field. You get the base theme name and version, and whether it is a Theme Store theme or a custom-built one.

**Can it detect which apps a Shopify store has installed?** Yes. The `apps` field lists the apps found in the store's page source, such as Klaviyo, Judge.me, Yotpo, Recharge, Gorgias and 40+ more.

**Does it work as a website technology checker for sites that are not on Shopify?** No, it is built for Shopify stores only. Other sites come back with `isShopify: false` and are not charged.

**Something broke or a field is missing?** Open an issue on the Issues tab and we'll look at it.

### Disclaimer

This Actor is not affiliated with, endorsed or sponsored by Shopify Inc. Shopify is a trademark of Shopify Inc., used
here only to describe which stores the tool works with. App names are trademarks of their owners.

### About Reliable Tools

This Actor is made by [Reliable Tools](https://apify.com/reliable_tools). We build scrapers that return clean data plus
an AI label with a confidence score, so you can filter and act on the results straight away. Our focus is e-commerce,
product sourcing and lead research.

If a field is missing or a store doesn't parse the way you expect, open an issue on the Issues tab. We read every one
and usually reply within a day. You can find our other Actors on our [profile page](https://apify.com/reliable_tools).

# Actor input Schema

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

Shopify stores to analyze, e.g. allbirds.com or https://www.gymshark.com. Non-Shopify sites are returned with isShopify=false and are not charged.

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

Products read from the public catalog to compute price range, vendors and new-product velocity. 0 = skip the catalog. Maximum 1,000. Paths the store disallows in robots.txt are skipped.

## `aiClassification` (type: `boolean`):

Adds an AI label with confidence scores: niche category, business model (own brand, multi-brand, print-on-demand, digital, dropshipping) and target audience. Charged per store.

## Actor input object example

```json
{
  "stores": [
    "allbirds.com",
    "rosyspatterns.com"
  ],
  "maxProductsPerStore": 250,
  "aiClassification": true
}
```

# Actor output Schema

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

Dataset with one row per analyzed store.

# 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",
        "rosyspatterns.com"
    ]
};

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

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

```

## MCP server setup

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