# Shopify Competitor Product Intelligence (`lofomachines/shopify-competitor-product-intelligence`) Actor

Extract Shopify competitor product catalogs, prices, discounts, availability, variants, images, tags, SEO signals, and opportunity scores without requiring user login. WEBSITE MUST USE SHOPIFY.

- **URL**: https://apify.com/lofomachines/shopify-competitor-product-intelligence.md
- **Developed by:** [Lofomachines](https://apify.com/lofomachines) (community)
- **Categories:** E-commerce, SEO tools, MCP servers
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.49 / 1,000 products

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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 Competitor Product Intelligence

Turn Shopify stores, collections, and product pages into a clean competitor research dataset. This Actor helps e-commerce brands, agencies, product teams, dropshippers, Amazon sellers, and Shopify merchants monitor competing stores, compare prices, spot discounts, map assortments, and discover product opportunities without logging in to any external platform.

Paste a Shopify domain for full-catalog research, a collection URL for category research, or a product URL for a single-page check. The Actor automatically collects as much public product data as possible up to your selected limit and returns product names, prices, discount signals, availability, variants, images, tags, product types, SEO keywords, content scores, priority scores, and recommended actions.

### Why use this Actor?

Most Shopify competitor research is still done manually: opening product pages, copying prices into spreadsheets, checking sale items, counting variants, and trying to understand what competitors are pushing. This Actor turns that work into a repeatable data feed you can export to CSV, Excel, JSON, Google Sheets, Airtable, your BI tool, or your own workflow.

Use it for:

- Shopify competitor analysis
- Competitor price monitoring
- E-commerce product research
- DTC brand tracking
- Dropshipping product research
- Assortment gap analysis
- SEO and merchandising research
- Product launch monitoring
- Discount and promotion tracking
- Marketplace benchmarking

### What data do you get?

Each product row can include:

- Store URL, store domain, and detected store name
- Product title, product URL, handle, vendor, and product type
- Minimum price, maximum price, average price, and currency when available
- Compare-at prices, discount flag, and maximum discount percentage
- Availability, availability rate, in-stock variants, and out-of-stock variants
- Variant count, option names, SKUs, variant prices, and variant availability
- Product image URL, all detected image URLs, and image count
- Product tags, commercial labels, and SEO-friendly keywords
- Content score, priority score, opportunity signal, and recommended action
- Publish, creation, and update timestamps when available

### Input example

```json
{
    "storeUrls": [{ "url": "https://hiutdenim.co.uk" }, { "url": "https://hiutdenim.co.uk/collections/denim" }],
    "maxProductsPerStore": 500
}
````

### Output example

```json
{
    "storeDomain": "example-store.com",
    "productTitle": "Merino Wool Runner",
    "productUrl": "https://example-store.com/products/merino-wool-runner",
    "vendor": "Example Brand",
    "productType": "Sneakers",
    "currency": "USD",
    "minPrice": 89,
    "maxPrice": 129,
    "hasDiscount": true,
    "discountPercentMax": 25.5,
    "isAvailable": true,
    "availabilityRate": 0.75,
    "variantCount": 8,
    "imageUrls": ["https://cdn.example.com/product-front.jpg", "https://cdn.example.com/product-back.jpg"],
    "tags": ["men", "running", "wool"],
    "commercialTags": ["new arrival", "sustainable"],
    "searchKeywords": ["wool", "runner", "sneakers"],
    "contentScore": 82,
    "priorityScore": 76,
    "opportunitySignal": "Active discount",
    "recommendedAction": "Track this discount and compare it against your closest matching product."
}
```

### Practical use cases

#### Track competitor prices every week

Schedule the Actor to run weekly on your top competitors. Export the dataset to a spreadsheet and filter by discounts, priority score, and product type to see which products changed or deserve attention.

#### Find assortment gaps before launching a collection

Run several stores in the same niche and group products by product type, price band, tags, and variant count. This makes it easier to see where competitors are over-served, under-served, or using premium positioning.

#### Discover product ideas for a Shopify store

Use the priority score, commercial tags, and opportunity signal to shortlist products that may be worth deeper validation. This is useful for agencies, brand builders, dropshippers, and marketplace sellers.

#### Improve SEO and merchandising

Use product titles, tags, product types, keywords, content scores, and image counts to compare your own product pages against competitors. Find naming patterns, collection ideas, and content gaps faster.

#### Monitor discounts and promotions

Filter for products with discounts and high priority scores. This helps identify active promotions, sale-heavy competitors, and products that may be driving seasonal campaigns.

### Who is this for?

This Actor is built for non-technical users who need clean e-commerce intelligence quickly:

- Shopify merchants
- E-commerce agencies
- DTC brand teams
- Product researchers
- Dropshipping operators
- Amazon and marketplace sellers
- SEO consultants
- Growth marketers
- Competitive intelligence teams

### How to use it

1. Add Shopify store, collection, or product URLs.
2. Choose the maximum number of products you want from each URL.
3. Run the Actor.
4. Export the results as CSV, Excel, JSON, or connect the dataset to your workflow.

No external platform login is required from the user.

### Tips for best results

- Use store homepage URLs for full-catalog research and collection URLs for focused category research.
- Compare stores in the same niche for cleaner benchmarking.
- Run the Actor on a schedule if you want recurring competitor monitoring.
- Start with 100 to 500 products per store, then increase the limit for larger catalogs.
- Use the Apify dataset filters to focus on discounts, unavailable products, premium products, or high-priority rows.

### Explore more Actors

Want more data tools for lead generation, market research, e-commerce, SEO, and automation? Discover more Actors by Lofomachines here: <https://apify.com/lofomachines>

# Actor input Schema

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

Add competitor Shopify stores or collection pages you want to analyze.

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

Maximum number of products to return for each store.

## Actor input object example

```json
{
  "storeUrls": [
    {
      "url": "https://hiutdenim.co.uk"
    },
    {
      "url": "https://hiutdenim.co.uk/collections/denim"
    }
  ],
  "maxProductsPerStore": 500
}
```

# Actor output Schema

## `products` (type: `string`):

Clean product-level rows with pricing, availability, merchandising, and opportunity fields.

## `runSummary` (type: `string`):

Compact summary of stores analyzed, products saved, and skipped stores.

# 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": [
        {
            "url": "https://hiutdenim.co.uk"
        },
        {
            "url": "https://hiutdenim.co.uk/collections/denim"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lofomachines/shopify-competitor-product-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 = { "storeUrls": [
        { "url": "https://hiutdenim.co.uk" },
        { "url": "https://hiutdenim.co.uk/collections/denim" },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("lofomachines/shopify-competitor-product-intelligence").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": [
    {
      "url": "https://hiutdenim.co.uk"
    },
    {
      "url": "https://hiutdenim.co.uk/collections/denim"
    }
  ]
}' |
apify call lofomachines/shopify-competitor-product-intelligence --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Shopify Competitor Product Intelligence",
        "description": "Extract Shopify competitor product catalogs, prices, discounts, availability, variants, images, tags, SEO signals, and opportunity scores without requiring user login. WEBSITE MUST USE SHOPIFY.",
        "version": "0.1",
        "x-build-id": "NLkvCfIpzfbN03UZS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lofomachines~shopify-competitor-product-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lofomachines-shopify-competitor-product-intelligence",
                "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/lofomachines~shopify-competitor-product-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-lofomachines-shopify-competitor-product-intelligence",
                "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/lofomachines~shopify-competitor-product-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-lofomachines-shopify-competitor-product-intelligence",
                "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": "Shopify store or collection URLs",
                        "minItems": 1,
                        "maxItems": 25,
                        "type": "array",
                        "description": "Add competitor Shopify stores or collection pages you want to analyze.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxProductsPerStore": {
                        "title": "Products per store",
                        "minimum": 10,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of products to return for each store.",
                        "default": 500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
