# Shopify Store Analyzer - Catalog, Contacts & Pricing (`webdata_labs/shopify-store-enricher`) Actor

\[💵 $2.00 / 1K] Turn Shopify store domains into catalog stats, product samples, contact emails, social links, currency, and brand intelligence.

- **URL**: https://apify.com/webdata\_labs/shopify-store-enricher.md
- **Developed by:** [WebData Labs](https://apify.com/webdata_labs) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 enriched stores

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/platform/actors/running/actors-in-store#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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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 Analyzer - Products, Contacts & Catalog Intelligence

**Turn Shopify store domains into clean store intelligence - catalog stats, product samples, contact emails, social links, currency, and brand signals.**

Shopify Store Analyzer takes a list of Shopify store domains and returns structured JSON/CSV rows for B2B sellers, agencies, sourcing teams, and competitive-intelligence analysts. Bring the domains (from your lead lists, trade shows, or any source) and get outreach-ready, analysis-ready store profiles - no manual store-by-store digging.

### ✅ What you get / ❌ what this isn't

| This Actor gives you | This Actor is not |
|---|---|
| Store summary rows with catalog size, pricing range, vendors, and product types | Not an official Shopify API |
| Contact emails and social links pulled from the store's own pages | Not a private-data scraper |
| Currency, store name, and catalog freshness dates | Not a keyword store-discovery engine (you supply the domains) |
| Optional per-product rows (title, vendor, type, price, dates) | Not a checkout or order scraper |
| A reliable Shopify check per domain | Not a guarantee every store leaves products.json public |

### 🔎 Why use this Actor

- Qualify and enrich lists of Shopify stores before outreach.
- Audit a competitor's catalog size, pricing band, and product mix.
- Pull store contact emails and socials for partnership or sales workflows.
- Track catalog freshness (newest product dates) across many stores.
- Feed clean store rows into spreadsheets, CRMs, BI tools, or LLM workflows.

### 🗂️ What data you get

| Field | Type | Description |
|---|---|---|
| `domain` | string | Normalized store domain |
| `storeName` | string | Store name from the homepage |
| `isShopify` | boolean | Whether a public Shopify catalog was detected |
| `productsSampled` | number | Products read for this run |
| `currency` | string | Store currency code when detectable |
| `priceMin`, `priceMax`, `priceAvg` | number | Price band across sampled products |
| `uniqueVendors`, `topVendors` | number/array | Brand mix in the catalog |
| `uniqueProductTypes`, `topProductTypes` | number/array | Product-type mix |
| `newestProductDate`, `oldestProductDate` | string | Catalog freshness signals |
| `contactEmails` | array | Public emails from the store's pages |
| `socialLinks` | array | Public social profile links |

### 👥 Who it's for

- B2B sellers and agencies prospecting Shopify merchants.
- Sourcing and wholesale teams qualifying store catalogs.
- Competitive-intelligence analysts comparing catalogs and pricing.
- Data teams building ecommerce store datasets.
- Anyone enriching a list of store domains into outreach-ready rows.

### Example tasks

- [Enrich a list of Shopify stores with contacts](https://apify.com/webdata_labs/shopify-store-enricher/examples/enrich-a-list-of-shopify-stores-with-contacts)
- [Audit a competitor Shopify catalog and pricing](https://apify.com/webdata_labs/shopify-store-enricher/examples/audit-a-competitor-shopify-catalog-and-pricing)
- [Export Shopify store product samples](https://apify.com/webdata_labs/shopify-store-enricher/examples/export-shopify-store-product-samples)

### ⚙️ How to analyze Shopify stores

1. Open the Actor on Apify.
2. Paste one or more Shopify store domains or URLs.
3. Choose how many products to sample per store.
4. Optionally include per-product rows.
5. Run the Actor.
6. Open the dataset view for `Store summaries` or `Product rows`.
7. Export JSON, CSV, Excel, HTML, RSS, or XML, or call the Actor through the Apify API.

### 📥 Input

```json
{
  "storeUrls": ["allbirds.com", "gymshark.com"],
  "maxProductsPerStore": 50,
  "includeContacts": true,
  "includeProductRows": false
}
````

### 📤 Output

```json
{
  "recordType": "store_summary",
  "domain": "allbirds.com",
  "storeName": "Allbirds",
  "isShopify": true,
  "productsSampled": 50,
  "currency": "USD",
  "priceMin": 18.0,
  "priceMax": 145.0,
  "priceAvg": 78.4,
  "topProductTypes": ["Shoes", "Socks", "Apparel"],
  "contactEmails": ["help@allbirds.com", "bulkorders@allbirds.com"],
  "socialLinks": ["https://instagram.com/allbirds", "https://facebook.com/allbirds"]
}
```

### 💵 How much does it cost?

The launch price is about `$2.00 / 1,000 enriched stores`, tier-discounted for higher Apify plans. Sampling more products per store increases run time but not the per-store price.

### 🔁 Run it on the Apify platform

Schedule recurring catalog and contact refreshes, call it from the Apify API, export to CSV/JSON/Excel, or connect the dataset to Make, Zapier, webhooks, a warehouse, or an LLM pipeline.

### ⚠️ Limits and caveats

- This Actor reads public Shopify store endpoints and pages. It is not affiliated with Shopify.
- You supply the store domains. This Actor enriches them; it does not discover stores by keyword or category.
- Some stores disable their public `products.json`; those return `isShopify: false` with a note instead of catalog data.
- Contact emails come from public pages and may include role or support addresses. Use the output lawfully and avoid storing or processing personal data without a legitimate reason.
- Catalog stats are based on the products sampled in the run, not necessarily the full catalog.

### 🧩 Related Actors

- Website Contact Extractor - turn any company domain into outreach-ready emails and socials.
- Lead List Deduplicator - clean and merge store/lead rows before CRM import.
- Trustpilot Review Scraper - add reputation signal to ecommerce brands.
- Bulk URL Status Checker - audit store URLs before monitoring or outreach.

### ❓ FAQ

#### Does this find Shopify stores by keyword?

No. You provide the store domains; this Actor enriches them into catalog and contact intelligence. Pair it with your own lead source or a discovery tool.

#### How does it know a site is Shopify?

It checks the store's public Shopify product endpoint. If a public catalog is found, the store is treated as Shopify and enriched.

#### Can it return individual products?

Yes. Turn on `includeProductRows` to also output one row per sampled product.

#### Why do some stores show `isShopify: false`?

Either the site is not Shopify, or the store disabled its public `products.json`. The Actor records this instead of failing the run.

### 🛠️ Support

For bugs or missing fields, open an Actor issue with the run URL, input, and the field or behavior you expected.

### ⭐ Rate this Actor

If this Actor saved you time, please take 30 seconds to leave a review on the **Reviews** tab of [Shopify Store Analyzer - Catalog, Contacts & Pricing](https://apify.com/webdata_labs/shopify-store-enricher) - reviews are the main trust signal other users see, and they directly decide which features get built next. If something is broken or a field is missing, please [open an issue](https://apify.com/webdata_labs/shopify-store-enricher/issues) first - we typically respond within a day and would love the chance to fix it before you rate.

# Actor input Schema

## `storeUrls` (type: `array`):

Shopify store domains or URLs, for example allbirds.com or https://gymshark.com. Any URL from the store works; it is reduced to the domain.

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

How many products to sample per store for catalog stats and product rows. Higher values give better stats but cost more.

## `includeContacts` (type: `boolean`):

Fetch the homepage and contact page to extract emails, social links, currency, and store name.

## `includeProductRows` (type: `boolean`):

Also output one row per sampled product (title, vendor, type, price, dates). Leave off for summary-only audits.

## Actor input object example

```json
{
  "storeUrls": [
    "allbirds.com"
  ],
  "maxProductsPerStore": 50,
  "includeContacts": true,
  "includeProductRows": false
}
```

# Actor output Schema

## `OUTPUT` (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 = {
    "storeUrls": [
        "allbirds.com"
    ]
};

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

# Run the Actor and wait for it to finish
run = client.actor("webdata_labs/shopify-store-enricher").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "storeUrls": [
    "allbirds.com"
  ]
}' |
apify call webdata_labs/shopify-store-enricher --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=webdata_labs/shopify-store-enricher",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Shopify Store Analyzer - Catalog, Contacts & Pricing",
        "description": "[💵 $2.00 / 1K] Turn Shopify store domains into catalog stats, product samples, contact emails, social links, currency, and brand intelligence.",
        "version": "0.1",
        "x-build-id": "yHJx9b8WAHQGWyT55"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/webdata_labs~shopify-store-enricher/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-webdata_labs-shopify-store-enricher",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/webdata_labs~shopify-store-enricher/runs": {
            "post": {
                "operationId": "runs-sync-webdata_labs-shopify-store-enricher",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/webdata_labs~shopify-store-enricher/run-sync": {
            "post": {
                "operationId": "run-sync-webdata_labs-shopify-store-enricher",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "storeUrls"
                ],
                "properties": {
                    "storeUrls": {
                        "title": "Store URLs or domains",
                        "type": "array",
                        "description": "Shopify store domains or URLs, for example allbirds.com or https://gymshark.com. Any URL from the store works; it is reduced to the domain.",
                        "default": [
                            "allbirds.com",
                            "gymshark.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxProductsPerStore": {
                        "title": "Max products per store",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "How many products to sample per store for catalog stats and product rows. Higher values give better stats but cost more.",
                        "default": 50
                    },
                    "includeContacts": {
                        "title": "Include contacts and brand info",
                        "type": "boolean",
                        "description": "Fetch the homepage and contact page to extract emails, social links, currency, and store name.",
                        "default": true
                    },
                    "includeProductRows": {
                        "title": "Include individual product rows",
                        "type": "boolean",
                        "description": "Also output one row per sampled product (title, vendor, type, price, dates). Leave off for summary-only audits.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
