# Shopify Competitor Assortment Comparator — Product Gap Finder (`delta_tools/competitor-assortment-comparator`) Actor

Compare your Shopify catalog with competitor stores product by product. Get the specific products rivals carry that you do not, with prices and variant counts, as structured records, plus overlap and median price summaries per store.

- **URL**: https://apify.com/delta_tools/competitor-assortment-comparator.md
- **Developed by:** [Delta Tools](https://apify.com/delta_tools) (community)
- **Categories:** E-commerce, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 store comparisons

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/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 Competitor Assortment Comparator — Product Gap Finder

Scrapers collect one store at a time, and store analyzers give you benchmarks and dashboards. This Actor answers the assortment question directly: **which specific products do your rivals carry that you do not?**

Give it your Shopify store and up to 10 competitor stores. It reads each public catalog, matches products across stores by title and handle, and returns structured records you can sort, filter, and price against:

- **comparison-summary** (one per competitor): catalog sizes, overlap count and rate, gap count, and median prices for you vs them
- **assortment-gap** (one per product you lack): title, product URL, price range, variant count, availability, product type, vendor, publish date — plus the closest product in your own catalog and how close it is, so you can tell a true gap from a renaming
- **overlap** (one per shared product): both titles, both prices, and the match similarity

### Who it is for

Shopify merchants and ecommerce teams doing assortment planning, range reviews, or competitor research — anyone who has ever opened two rival stores in two tabs and tried to diff them by eye.

### Input

- **Your Shopify store** — your domain (required)
- **Competitor stores** — 1 to 10 Shopify domains (required)
- **Match threshold** — how close a title must be to count as the same product (default 0.8)
- **Max products per store** — catalog read cap (default 1000)
- **Include overlap records** — turn off for a gap-only list

### Pricing

Pay per event: **$0.005 per competitor store compared**, plus the standard Actor start. Comparing your store against 3 rivals costs about two cents.

### Notes

- Catalogs come from each store's public `products.json` feed — the same data the storefront itself exposes. Stores that disable that feed cannot be compared.
- Matching is title and handle based with explainable similarity scores; borderline pairs are flagged with their closest match and score rather than silently dropped, so you can audit the calls yourself.
- Prices are each store's own listed prices in that store's currency.

# Actor input Schema

## `competitorStores` (type: `array`):

Competitor Shopify store domains to compare against yours (1-10), e.g. rival-store.com. Each store compared counts as one billable store-compared event.

## `includeOverlaps` (type: `boolean`):

Also output one record per product both stores carry, with the match similarity and both prices. Turn off to get only the gap list and summaries.

## `matchThreshold` (type: `number`):

Title similarity (0.5-1.0) at or above which a competitor product counts as one you already carry. Lower it for fuzzier matching, raise it to count only near-identical products as overlaps.

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

Maximum products to read per store catalog (50-2500). Large catalogs take longer to compare.

## `yourStore` (type: `string`):

Your own Shopify store domain, e.g. your-store.com (or its .myshopify.com domain).

## Actor input object example

```json
{
  "competitorStores": [
    "mahabis.com"
  ],
  "includeOverlaps": true,
  "matchThreshold": 0.8,
  "maxProductsPerStore": 1000,
  "yourStore": "allbirds.com"
}
```

# Actor output Schema

## `available` (type: `string`):

Whether any variant is currently available (as text).

## `closestSimilarity` (type: `string`):

Similarity of the closest product in your catalog (gap records).

## `closestYourProduct` (type: `string`):

Closest-matching product title in your own catalog (gap records).

## `comparedAt` (type: `string`):

UTC timestamp of the comparison (summary records).

## `competitorMedianPrice` (type: `string`):

Median product price in the competitor's catalog, in that store's currency (summary records).

## `competitorProductCount` (type: `string`):

Number of products read from the competitor's catalog (summary records, as text).

## `competitorStore` (type: `string`):

The competitor store domain.

## `error` (type: `string`):

Present only on comparison-error records, when a competitor store could not be fetched; error records are not charged.

## `gapCount` (type: `string`):

Number of competitor products you do not carry (summary records).

## `handle` (type: `string`):

Product handle (slug) on the competitor's store.

## `imageUrl` (type: `string`):

Main product image URL on the competitor's store.

## `matchSimilarity` (type: `string`):

Title similarity of a matched pair (overlap records).

## `overlapCount` (type: `string`):

Number of competitor products you also carry (summary records).

## `overlapRate` (type: `string`):

Share of the competitor's catalog that overlaps yours, 0-1 (summary records, as text).

## `possibleMatch` (type: `string`):

Whether the closest product in your catalog is a possible renamed match, similarity at or above 0.5 (gap records, as text).

## `priceMax` (type: `string`):

Highest variant price for the product, in the store's own currency.

## `priceMin` (type: `string`):

Lowest variant price for the product, in the store's own currency.

## `priceNote` (type: `string`):

Currency note for the summary price fields.

## `productType` (type: `string`):

Product type/category as listed by the competitor store.

## `publishedAt` (type: `string`):

Date the product was published on the competitor's store.

## `recordType` (type: `string`):

comparison-summary, assortment-gap, overlap, or comparison-error.

## `tags` (type: `string`):

Product tags as listed by the competitor store, as JSON text.

## `title` (type: `string`):

Product title (gap and overlap records).

## `topGapProducts` (type: `string`):

First gap product titles, as JSON text (summary records).

## `url` (type: `string`):

Product page URL on the competitor's store.

## `variantCount` (type: `string`):

Number of variants the competitor lists for the product (as text).

## `vendor` (type: `string`):

Product vendor/brand as listed by the competitor store.

## `yourMedianPrice` (type: `string`):

Median product price in your catalog, in your store's currency (summary records).

## `yourPriceMax` (type: `string`):

Highest variant price of your matched product, in your store's currency (overlap records).

## `yourPriceMin` (type: `string`):

Lowest variant price of your matched product, in your store's currency (overlap records).

## `yourProductCount` (type: `string`):

Number of products read from your catalog (summary records, as text).

## `yourStore` (type: `string`):

Your store domain.

## `yourTitle` (type: `string`):

Your product's title for a matched pair (overlap records).

## `yourUrl` (type: `string`):

Your product page URL for a matched pair (overlap records).

# 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 = {
    "competitorStores": [
        "mahabis.com"
    ],
    "includeOverlaps": true,
    "matchThreshold": 0.8,
    "maxProductsPerStore": 1000,
    "yourStore": "allbirds.com"
};

// Run the Actor and wait for it to finish
const run = await client.actor("delta_tools/competitor-assortment-comparator").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 = {
    "competitorStores": ["mahabis.com"],
    "includeOverlaps": True,
    "matchThreshold": 0.8,
    "maxProductsPerStore": 1000,
    "yourStore": "allbirds.com",
}

# Run the Actor and wait for it to finish
run = client.actor("delta_tools/competitor-assortment-comparator").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 '{
  "competitorStores": [
    "mahabis.com"
  ],
  "includeOverlaps": true,
  "matchThreshold": 0.8,
  "maxProductsPerStore": 1000,
  "yourStore": "allbirds.com"
}' |
apify call delta_tools/competitor-assortment-comparator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,delta_tools/competitor-assortment-comparator"
        }
    }
}
```

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/i7JPHI3iqXBzW8T6D/builds/VG5y5aB15jndhywai/openapi.json