# Shopify & WooCommerce Store Intelligence API (`fxjima/shopify-woocommerce-store-intelligence`) Actor

Enrich store domains: Shopify/WooCommerce detection, theme, catalog size, price range, stock ratio, evidence-backed app & pixel stack and public business contacts.

- **URL**: https://apify.com/fxjima/shopify-woocommerce-store-intelligence.md
- **Developed by:** [mihai marin](https://apify.com/fxjima) (community)
- **Categories:** E-commerce, Lead generation, AI
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.00 / 1,000 store enricheds

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 & WooCommerce Store Intelligence API** takes the store domains you already have and returns one structured profile per store. Each profile covers the **platform and theme**, **catalog size and price range**, **stock and discount ratios**, an **evidence-backed app and pixel stack**, and **public business contacts**. It works on [Shopify](https://www.shopify.com) and [WooCommerce](https://woocommerce.com) storefronts, uses plain HTTP (no browser, no login), and **charges only for stores it fully enriched**.

> **Try it in one click.** The input is prefilled with three real stores (two Shopify, one WooCommerce). Press **Start** and the results appear within seconds.

### What does Shopify & WooCommerce Store Intelligence do?

Paste a list of domains such as `allbirds.com` or `https://shop.example.com/collections/all`. For each one, the Actor:

1. **Identifies the platform**: Shopify, WooCommerce, or one of 11 other platforms (Magento, BigCommerce, Shopware, PrestaShop, Wix, Squarespace and more). Every detection comes with a confidence level and the signals that triggered it.
2. **Reads the theme**: the Shopify theme and its base theme (for example a renamed copy of *Dawn 10.0.0*), or the active and parent theme for WooCommerce.
3. **Profiles the catalog** through the store's own public endpoints: Shopify `products.json` and `meta.json`, or the WooCommerce Store API. If those are switched off, it falls back to the product sitemap plus structured product data. The result includes product count, estimated SKUs, min/median/max/average price, discounted share, in-stock ratio, top vendors, top categories, and the newest and oldest product dates.
4. **Detects about 100 apps, pixels and services**: Klaviyo, Attentive, Gorgias, Zendesk, Recharge, Yotpo, Judge.me, Okendo, Rebuy, Triple Whale, Elevar, Meta, TikTok, Google Ads, Pinterest, Reddit and Snap pixels, Klarna, Afterpay, Cookiebot and more. **Each hit includes the exact evidence string**, so you can verify it yourself.
5. **Collects public business contact signals**: role-based mailboxes (`support@`, `info@`, …), phone numbers the store publishes as `tel:` links or structured data, official social profiles, and the contact page URL. Personal addresses are never returned.

### Why use this store intelligence API?

- 🎯 **Agencies and SaaS sales teams.** Qualify a lead list before outreach. For example: Shopify stores with 200+ products that run Klaviyo but have no reviews app, or WooCommerce shops with no consent banner.
- 🧩 **App and partnership teams.** See which helpdesk, subscription, loyalty or reviews tools a target account already uses, together with the proof.
- 📈 **Competitive and market research.** Track catalog growth, pricing bands, discount depth and stock levels across a set of competitors. Schedule the run weekly and compare the outputs.
- 💼 **Investors and brand aggregators.** Get a quick, repeatable snapshot of a DTC brand's catalog breadth, price architecture and marketing stack.
- 🤖 **AI agents.** `compactOutput` returns one small JSON object per store, built for the Apify MCP server and LLM tool calls.

Unlike store-discovery databases, this Actor **enriches your own list, live, at the moment you run it**. The output shows how every number was obtained (`productCountSource`, `catalogAttempts`, `evidence`), which makes it suitable for CRM enrichment and audits.

### What data can it extract?

| Field | Example | Description |
|---|---|---|
| `status` | `enriched` | `enriched` is the only billable status. All other statuses cost $0 (see [statuses](#what-do-the-statuses-mean)). |
| `platform` / `platformConfidence` | `shopify` / `high` | Detected platform and confidence, with `platformEvidence`. |
| `theme.name` / `theme.schemaName` / `theme.version` | `Dawn` `10.0.0` | Storefront theme, its base theme, and version. |
| `store.name`, `country`, `city`, `currency`, `language` | `US`, `USD`, `en` | Public store profile (Shopify adds `myshopifyDomain`, `collectionsCount`, `shipsToCountriesCount`). |
| `catalog.productCount` | `165` | Published products, with `productCountSource` (e.g. `shopify-meta.json`). |
| `catalog.estimatedSkuCount` | `448` | Products × average variants. |
| `catalog.priceMin` / `priceMedian` / `priceMax` | `5` / `25` / `90` | Price range in the store currency. |
| `catalog.discountedShare` | `0.352` | Share of products currently on sale. |
| `catalog.inStockRatio` | `0.873` | Share of variants (or products) in stock. |
| `catalog.topVendors` / `topCategories` | `Coffee: 37` | Top 5 brands and categories by product count. |
| `techStack[]` | `Klaviyo`, `email-sms-marketing`, evidence | Detected apps and pixels, each with its proof. |
| `contacts` | `support@…`, `+1…`, social links | Public business contacts only. |
| `products[]` (optional) | title, price, stock, SKU, image | Newest products first, when `includeProducts` is on. |

### How to enrich a list of Shopify or WooCommerce stores

1. Click **Try for free** or **Start** on this page.
2. Paste your store domains or URLs into **Store domains** (one per line). `www.` variants and duplicates are merged automatically.
3. Optional: turn on **Include products** to add the newest products for each store, or **Compact output** for AI agents.
4. Click **Start**. The three prefilled stores take about 10–15 seconds, and 100 stores a few minutes.
5. Download the results as **JSON, CSV, Excel or HTML** from the **Output** tab, or fetch them through the API, n8n, Make or MCP.

### How much does it cost to analyze a Shopify store?

This Actor uses **pay per event**, and you pay only for real results:

| Event | Price | When it is charged |
|---|---|---|
| Store enriched | **$0.004** per store ($4 per 1,000) | The store was identified as Shopify or WooCommerce **and** its catalog was profiled (`status: enriched`). |
| Anything else | **$0** | Unreachable, blocked, invalid, non-store, unsupported-platform and partial rows are free. |

- Platform compute is included. You pay only the event price above.
- The Apify **free plan's $5 monthly credit covers about 1,250 enriched stores**.
- The Actor respects your run's **maximum total charge**. When the limit is reached it stops, and every remaining store gets a free `skipped_charge_limit` row so no input is silently dropped.

### Input

All options are in the **Input** tab. The main fields:

```json
{
    "domains": ["allbirds.com", "deathwishcoffee.com", "auntfannies.com"],
    "includeProducts": false,
    "maxProductsPerStore": 25,
    "compactOutput": false,
    "maxCatalogProducts": 500,
    "maxItems": 0
}
```

- `domains` / `urls`: bare domains or full URLs; both are accepted and normalized.
- `maxCatalogProducts`: how many products to read for the price and stock metrics. The product **count** stays exact either way when the store publishes it.
- `maxItems`: process only the first N unique stores (`0` = all).
- `respectRobotsTxt` (default on): endpoints that a store's robots.txt disallows are skipped.

### Output

Results are stored in a dataset. You can download it in various formats such as JSON, HTML, CSV or Excel. Below is a shortened record from a real test run:

```json
{
    "domain": "deathwishcoffee.com",
    "status": "enriched",
    "platform": "shopify",
    "platformConfidence": "high",
    "theme": { "name": "VD Sale+Retainer | deathwish-shopify-20/production", "schemaName": "Dawn", "version": "10.0.0" },
    "store": { "name": "Death Wish Coffee", "country": "US", "city": "Round Lake", "currency": "USD", "language": "en", "collectionsCount": 127, "shipsToCountriesCount": 224 },
    "catalog": {
        "source": "shopify-products-json",
        "productCount": 165,
        "productCountSource": "shopify-meta.json",
        "estimatedSkuCount": 448,
        "priceMin": 5, "priceMedian": 25, "priceMax": 90,
        "discountedShare": 0.352,
        "inStockRatio": 0.873,
        "topCategories": [{ "name": "Apparel", "count": 39 }, { "name": "Coffee", "count": 37 }],
        "newestProductPublishedAt": "2026-11-18T15:54:37-05:00"
    },
    "techStack": [
        { "name": "Klaviyo", "category": "email-sms-marketing", "evidence": "static.klaviyo.com/onsite/js/Q6RhjR/klaviyo.js?company_id=Q6RhjR" },
        { "name": "Rebuy", "category": "upsell-personalization", "evidence": "rebuyengine.com/onsite/js/rebuy.js?shop=deathwishcoffee.myshopify.com" },
        { "name": "NoFraud", "category": "fraud-risk", "evidence": "services.nofraud.com" }
    ],
    "detectedAppsCount": 8,
    "contacts": {
        "emails": [],
        "phones": [],
        "socialLinks": { "instagram": "https://www.instagram.com/deathwishcoffee", "youtube": "https://www.youtube.com/channel/UC1uurJMded2rRJioe8yka7g" },
        "contactPageUrl": "https://www.deathwishcoffee.com/pages/help"
    },
    "requestsMade": 9,
    "durationMs": 2574
}
```

The same store with `compactOutput: true`:

```json
{ "domain": "deathwishcoffee.com", "status": "enriched", "platform": "shopify", "themeName": "Dawn", "country": "US", "currency": "USD", "productCount": 165, "skuCount": 448, "price": { "min": 5, "median": 25, "max": 90 }, "inStock": 0.873, "onSale": 0.352, "apps": ["Klaviyo", "Meta Pixel", "Google Ads", "Google & YouTube (Shopify app)", "MNTN (CTV ads)", "Vibe (CTV ads)", "Rebuy", "NoFraud"], "email": null, "phone": null, "socials": ["x", "facebook", "instagram", "youtube"] }
```

A free row, here a domain that does not exist:

```json
{ "domain": "not-a-real-store-xyz123.com", "status": "unreachable", "failureReason": "domain does not resolve (ENOTFOUND)", "requestsMade": 0 }
```

The run's key-value store also holds a `SUMMARY` record with the billable count, a breakdown by status, and the request and download totals.

#### What do the statuses mean?

| Status | Billed | Meaning |
|---|---|---|
| `enriched` | ✅ | Shopify or WooCommerce store with a profiled catalog. |
| `partial` | $0 | Store detected, but no catalog source answered (for example, all endpoints disallowed or switched off). |
| `unsupported_platform` | $0 | Another e-commerce platform was identified (named in `platform`). |
| `not_ecommerce` | $0 | No storefront was found on the homepage. |
| `blocked` | $0 | A bot-protection challenge was shown. It is **never bypassed**, by design. |
| `unreachable` / `invalid_input` / `robots_disallowed` | $0 | DNS, network or HTTP errors; non-public or invalid hosts; or a robots.txt opt-out. |
| `skipped_charge_limit` | $0 | Your run's spending limit was reached before this store was processed. |

### Use it from AI agents (MCP)

Add this Actor as a tool through the hosted [Apify MCP server](https://mcp.apify.com):

```text
https://mcp.apify.com/?tools=fxjima/shopify-woocommerce-store-intelligence
```

**Claude Code:**

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=fxjima/shopify-woocommerce-store-intelligence"
```

**Claude Desktop, Cursor, VS Code** and other MCP clients:

```json
{
    "mcpServers": {
        "apify": { "url": "https://mcp.apify.com/?tools=fxjima/shopify-woocommerce-store-intelligence" }
    }
}
```

The server signs you in with OAuth. If your client can't do OAuth, add an `"headers": { "Authorization": "Bearer <APIFY_TOKEN>" }` header instead. Ask your agent to call the tool with `compactOutput: true` to keep responses small.

### Use it with n8n, Make, Zapier or the API

- **n8n:** add the **Apify** node, choose *Run an Actor and get dataset items*, select `fxjima/shopify-woocommerce-store-intelligence`, and pass `{"domains": {{ $json.domains }}}`. Every result row then flows into your CRM, Google Sheets or Slack node.
- **Make / Zapier:** use the Apify app's *Run an Actor* action, then *Get dataset items*.
- **HTTP API**: a synchronous call for small batches (under 5 minutes):

```bash
curl -X POST "https://api.apify.com/v2/acts/fxjima~shopify-woocommerce-store-intelligence/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" -H "Content-Type: application/json" \
  -d '{"domains": ["allbirds.com", "auntfannies.com"], "compactOutput": true}'
```

### Tips for faster, cheaper runs

- Keep **Include products** off unless you need product rows. The catalog metrics are computed either way.
- Lower `maxCatalogProducts` (for example to 250) to profile very large catalogs with fewer requests. The exact product count still comes from `meta.json` or `X-WP-Total` when the store publishes it.
- Set a **maximum total charge** on the run to cap your spend precisely.
- Schedule the Actor (daily, weekly or monthly) on the same list to watch catalog, price and app-stack changes over time.

### FAQ

#### Can it analyze any Shopify or WooCommerce store?

It works on most of them. Stores that disable `products.json` or the Store API are profiled from their product sitemap and structured product data: `catalog.metricsFromSample` is then `true` and `catalogAttempts` explains what happened. Stores behind an active bot challenge are returned as `blocked` at $0. The Actor never bypasses protections, logins or CAPTCHAs.

#### Does it collect personal data?

No. It reads public storefront pages and public catalog endpoints only. Email addresses are kept only when they are role-based business mailboxes (such as `support@` or `sales@`), and phone numbers only when the store itself publishes them as a `tel:` link or in structured data.

#### How accurate is app detection?

Each detection is based on a concrete asset URL, script global, Web Pixels configuration key or response header, and the matched evidence is returned with the hit. Apps that load only after user interaction, or only on checkout pages, may not be visible on the homepage.

#### Is it a store-finder?

No. It enriches the domains you provide. To build a list first, combine it with any source of domains (your CRM, a spreadsheet, or another Actor) and chain the runs through the API or n8n.

### Disclaimer and support

This Actor is ethical and does not extract private user data. It extracts only what store owners publish on their own public storefronts. However, your results could contain personal data, which is protected by the GDPR in the European Union and by other regulations around the world. Do not process personal data unless you have a legitimate reason to do so. If you are unsure whether your reason is legitimate, consult your lawyers. Shopify and WooCommerce are trademarks of their respective owners. This Actor is not affiliated with or endorsed by them.

Found a store that is detected incorrectly, or need another platform or app signature? Open an issue in the **Issues** tab with the domain, and it will usually be handled within a few days. For programmatic access, see the **API** tab.

# Actor input Schema

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

One store per line. Bare domains (allbirds.com), www hosts or full URLs (https://shop.example.com/collections/all) are all accepted; paths are ignored and duplicates are removed.

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

Optional second list for API and workflow callers (n8n, Make, Zapier) that already hold full URLs. Merged with Store domains.

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

Adds a products\[] array (newest first) with title, URL, price, compare-at price, stock and SKU for each store. Same price per store.

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

How many products to return in products\[] when Include product rows is on.

## `compactOutput` (type: `boolean`):

Returns one small, token-efficient object per store (status, platform, counts, prices, app names, first contact) instead of the full record. Ideal for MCP / LLM tool calls.

## `maxCatalogProducts` (type: `integer`):

Upper bound of catalog items read per store to compute price, stock and discount metrics. Exact product counts come from the platform where available; metrics are flagged when computed from a sample.

## `maxItems` (type: `integer`):

Stop after this many stores (0 = all). Useful for test runs and budget control together with the run's maximum total charge.

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

How many different stores are processed at the same time. Requests to one store are always sequential and paced.

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

Timeout for a single HTTP request. A timed-out request is retried once; rate-limited or failing requests twice.

## `respectRobotsTxt` (type: `boolean`):

When on (recommended), any URL disallowed by the store's robots.txt is skipped and alternative public sources are tried.

## Actor input object example

```json
{
  "domains": [
    "allbirds.com",
    "deathwishcoffee.com",
    "auntfannies.com"
  ],
  "includeProducts": false,
  "maxProductsPerStore": 25,
  "compactOutput": false,
  "maxCatalogProducts": 500,
  "maxItems": 0,
  "maxConcurrency": 5,
  "requestTimeoutSecs": 20,
  "respectRobotsTxt": true
}
```

# Actor output Schema

## `overview` (type: `string`):

Overview table view of the dataset.

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

All dataset items with every field.

## `summary` (type: `string`):

Billable count, status breakdown, requests and downloaded data for the run.

## `keys` (type: `string`):

All records saved by the run (SUMMARY, STATE).

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

// Run the Actor and wait for it to finish
const run = await client.actor("fxjima/shopify-woocommerce-store-intelligence").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",
        "auntfannies.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("fxjima/shopify-woocommerce-store-intelligence").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",
    "auntfannies.com"
  ]
}' |
apify call fxjima/shopify-woocommerce-store-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fxjima/shopify-woocommerce-store-intelligence"
        }
    }
}
```

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/IiJx9K4waXl1LApAk/builds/RwNFthRY3pUySwbZm/openapi.json
