# Shopify Store Intelligence - Products & Audit (`thirdwatch/shopify-store-intelligence-scraper`) Actor

Audit Shopify stores and extract products, variants, prices, collections, themes, contacts, social links, and marketing technologies.

- **URL**: https://apify.com/thirdwatch/shopify-store-intelligence-scraper.md
- **Developed by:** [Thirdwatch](https://apify.com/thirdwatch) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 store audits

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.

- **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 Intelligence Scraper

> Audit any public Shopify store and extract product, price, variant, collection, and catalog summary data over pure HTTP. No Shopify API key, login, browser, or merchant access required.

### What this actor does

Shopify Store Intelligence turns a list of Shopify domains or URLs into structured competitive intelligence:

- Store-level audit summary with store name, description, currency, theme, product/variant/collection counts, vendors, product types, price range, sale rate, and availability.
- Public contact emails, phone links, social profiles, and common marketing technologies found on the storefront.
- Product-level results from Shopify's public `/products.json` endpoint.
- Variant, SKU, price, compare-at price, inventory availability, image, tag, and publish/update metadata.
- Optional public collection discovery from `/collections.json`.

It is built for DTC analysts, ecommerce operators, lead generation teams, agencies, investors, and price-monitoring workflows that need fast Shopify catalog visibility without running a browser.

### Why use it

- **Pure HTTP by default:** Lower cost and faster runs than Playwright-based storefront crawlers.
- **Works with custom domains:** Use `brand.com`, `www.brand.com`, `brand.myshopify.com`, collection URLs, or product URLs.
- **Store audit + product feed:** Get one high-level audit row per store plus one row per product.
- **No credentials:** Uses only public storefront JSON endpoints.
- **Apify-ready output:** Dataset rows are structured for exports, integrations, and API consumption.

### Input

| Field | Required | Description |
|-------|----------|-------------|
| `storeUrls` | No | Shopify store homepages, product URLs, collection URLs, or myshopify.com URLs. |
| `storeDomains` | No | Plain domains such as `allbirds.com` or `gymshark.com`. Combined with `storeUrls`. |
| `maxProductsPerStore` | No | Maximum products to extract per store. Default `100`. |
| `includeCollections` | No | Fetch `/collections.json` where available. Default `true`. |
| `requestDelaySecs` | No | Polite delay between product pages. Default `0.5`. |
| `proxyConfiguration` | No | Residential proxy is enabled by default for stores that throttle cloud IPs. Disable it when direct requests work to minimize cost. |

Provide at least one value in `storeUrls` or `storeDomains`.

### Example input

```json
{
  "storeDomains": ["allbirds.com", "gymshark.com"],
  "maxProductsPerStore": 100,
  "includeCollections": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

### Output types

The dataset contains two result types.

#### Store audit result

One `store_audit` row is emitted per input store.

```json
{
  "result_type": "store_audit",
  "store_domain": "allbirds.com",
  "store_url": "https://www.allbirds.com",
  "status": "shopify_detected",
  "products_found": 100,
  "collections_found": 24,
  "vendors": ["Allbirds"],
  "product_types": ["Accessories", "Shoes"],
  "price_min": 12.0,
  "price_max": 160.0,
  "available_products": 87,
  "products_on_sale": 14,
  "variants_found": 1260,
  "currency": "USD",
  "theme_name": "Allbirds",
  "contact_emails": ["help@example.com"],
  "social_links": ["https://instagram.com/example"],
  "technologies": ["Google Analytics", "Klaviyo", "Meta Pixel"],
  "sampled_at": "2026-06-03T10:00:00+00:00"
}
```

#### Product result

One `product_result` row is emitted per extracted Shopify product.

```json
{
  "result_type": "product_result",
  "store_domain": "allbirds.com",
  "store_url": "https://www.allbirds.com",
  "url": "https://www.allbirds.com/products/mens-wool-runners",
  "product_id": 4029431775334,
  "handle": "mens-wool-runners",
  "title": "Men's Wool Runners",
  "vendor": "Allbirds",
  "product_type": "Shoes",
  "tags": ["mens", "wool"],
  "min_price": 110.0,
  "max_price": 110.0,
  "on_sale": false,
  "available": true,
  "variant_count": 24,
  "variants": [
    {"id": 123, "title": "10 / Natural Grey", "sku": "WR-NG-10", "price": "110.00", "available": true}
  ]
}
```

### Pricing event concept

This actor is designed around two Pay-Per-Event events:

| Event | Charged when | Why |
|-------|--------------|-----|
| `store_audit` | A Shopify storefront is positively detected and an audit is produced. | Invalid, unreachable, and non-Shopify inputs are not charged. |
| `product_result` | A product row is extracted from `/products.json`. | Product-level catalog intelligence scales with result volume. |

### Use cases

- Competitive product catalog monitoring
- Shopify brand discovery and enrichment
- Price and sale tracking
- DTC lead qualification
- Investor and market mapping workflows
- Ecommerce agency audits
- Collection/category research

### Limitations

- Only public Shopify storefront data is extracted.
- Some stores disable or restrict `/products.json`; those stores may return `no_public_products_found`.
- Protected storefronts can require the residential proxy option; proxy traffic adds to run cost, so disable it for stores that allow direct cloud requests.
- Inventory quantities are not exposed by Shopify's public product JSON; availability is boolean at variant level.
- This actor does not call private Shopify Admin APIs and does not bypass store protections.

### FAQ

**Do I need a Shopify API key?**
No. The actor uses public storefront JSON endpoints.

**Does this work on custom domains?**
Yes. Provide either custom domains or `myshopify.com` domains.

**Does it scrape collections?**
Yes, when `includeCollections` is enabled and the store exposes `/collections.json`.

**Is this browser-based?**
No. It is a pure HTTP actor designed for low cost and speed.

More ecommerce scrapers at [thirdwatch.dev](https://thirdwatch.dev).

# Actor input Schema

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

Shopify store homepages, product URLs, collection URLs, or myshopify.com URLs.

## `storeDomains` (type: `array`):

Plain domains to analyze, such as allbirds.com or gymshark.com. Combined with Store URLs.

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

Maximum number of products to extract from each storefront.

## `includeCollections` (type: `boolean`):

Also fetch public collection metadata from /collections.json when available.

## `requestDelaySecs` (type: `number`):

Polite delay between paginated product requests for each store.

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

Residential proxy is recommended because some Shopify storefronts rate-limit cloud IPs. Disable it for stores that allow direct requests to minimize cost.

## Actor input object example

```json
{
  "storeUrls": [
    "https://www.allbirds.com"
  ],
  "maxProductsPerStore": 100,
  "includeCollections": true,
  "requestDelaySecs": 0.5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (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": [
        "https://www.allbirds.com"
    ]
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/6Sui25tNEiEeb3u2W/builds/iegolb3BlVIM4h0LV/openapi.json