Shopify Competitor Sale & New Arrival Insights

Track Shopify competitor discounts and new product launches

Turn public Shopify product catalogs into competitor pricing and assortment intelligence.

This Actor scans one or more Shopify stores and returns only products that carry a useful signal:

a product is currently on sale at or above your discount threshold;

a product was published within your new-arrival window.

Instead of paying for a complete catalog copy, you receive focused intelligence records plus free store-level and portfolio summaries.

No Shopify Admin API. No account. No login. No browser automation.

Key features

Shopify sale tracker

Competitor discount monitoring

Variant-level discount calculations

Shopify new arrivals detection

Multi-store competitor research

Minimum discount threshold

Configurable new-arrival window

Optional product-type filtering

Optional out-of-stock filtering

Up to 50 stores per run

Up to 25,000 catalog products scanned per store

Store-level sale-rate and discount summaries

Portfolio comparison across monitored stores

Top discounts, vendors, and product types

Structured JSON-ready output

Apify API, Tasks, Schedules, and integrations

Pay Per Event

Free store summaries and run summary

No charge for plain catalog rows that carry no intelligence

Unofficial community Actor. Not affiliated with, sponsored by, or endorsed by Shopify Inc. or by the stores being monitored. The Actor reads public storefront catalog data exposed by supported Shopify stores.

What this Actor is for

This Actor is designed for users who do not need another full Shopify catalog scraper.

Its purpose is to answer questions such as:

Which competitor products are discounted right now?

How deep are the discounts?

Which variants are actually on sale?

Which products were launched recently?

Which monitored store has the highest sale rate?

Which store is launching more new products?

Which stores currently show more out-of-stock products?

What are the deepest discounts across a competitor set?

The Actor turns a public Shopify catalog into a smaller set of actionable product signals.

Typical use cases include:

competitor pricing research;

promotion monitoring;

assortment research;

new-product discovery;

merchandising intelligence;

e-commerce market research;

pricing dashboards;

agency reporting;

scheduled competitor snapshots;

n8n, Make, Zapier, webhook, API, and database workflows.

Important: this is instant intelligence, not historical change tracking

This Actor is a snapshot intelligence tool.

It does not need a baseline run.

The first run can immediately identify:

products currently on sale recently published products store-level discount metrics store-level new-arrival metrics out-of-stock signals

It does not compare today's product price with yesterday's product price.

If your workflow requires persistent change events such as:

price changed stock changed product added product removed

use the companion:

Shopify Price & Catalog Monitor

Use this Actor for the current competitive picture.

Use the companion monitor for cross-run change detection.

Important: sale detection depends on compare_at_price

Shopify product variants can expose:

price compare_at_price

A discount is measurable when:

compare_at_price > price

The Actor calculates:

discountPct = (compare_at_price - price) / compare_at_price × 100

A product is flagged:

onSale: true

when at least one variant meets your:

minDiscountPct

threshold.

Honest limitation

Some Shopify stores run promotions through:

discount codes;

automatic checkout discounts;

collection-level campaign mechanics;

customer-specific pricing;

other mechanisms not reflected in compare_at_price.

Those promotions cannot be reliably detected from the public catalog endpoint used by this Actor.

A store can therefore be running a promotion while showing:

onSaleCount: 0

if its public variant data does not expose a usable compare-at price.

The Actor does not invent a discount when the source does not expose one.

Who it's for

E-commerce and pricing teams

Use the Actor to compare competitor promotion intensity.

Examples:

percentage of scanned products on sale;

deepest active discounts;

median detectable discount;

new arrivals;

out-of-stock rate.

Brands and merchants

Monitor a competitive set before:

changing prices;

launching a promotion;

planning a seasonal sale;

launching a new collection;

reviewing assortment strategy.

Agencies

Run the same structured competitor scan across multiple client accounts.

The output can feed:

client dashboards;

recurring reports;

Google Sheets;

internal databases;

automated summaries.

Market researchers

Study public catalog behavior across Shopify stores without manually opening hundreds or thousands of product pages.

Automation builders

Connect structured results to:

n8n;

Make;

Zapier;

webhooks;

databases;

Slack;

Google Sheets;

BI tools;

internal applications;

AI agents.

How it works

For each store, the Actor:

normalizes the supplied domain;

reads the store's public Shopify catalog endpoint;

paginates through products up to maxProductsPerStore;

inspects product variants;

calculates detectable discount percentages;

identifies recent products from published_at;

applies your filters;

writes billable PRODUCT_INTEL records only when real intelligence is present;

writes a free STORE_INTEL_SUMMARY;

writes a free RUN_SUMMARY at the end of the run.

Catalog pages are processed serially per store with controlled pacing and retry behavior.

Input

Example

{
  "stores": [
    "allbirds.com",
    "deathwishcoffee.com"
  ],
  "minDiscountPct": 10,
  "newArrivalWindowDays": 30,
  "includeOutOfStock": true,
  "productTypeFilter": [],
  "maxProductsPerStore": 5000,
  "maxResults": 500,
  "maxRuntimeMs": 300000
}

Input fields

Field	Default	Description
stores	required	Shopify store domains such as allbirds.com. Maximum 50 entries per run.
minDiscountPct	5	Minimum variant discount required for a product to count as on sale. Range: 1–90.
newArrivalWindowDays	30	A product published within this window counts as a new arrival. Range: 1–365 days.
includeOutOfStock	true	When false, fully sold-out products are excluded from PRODUCT_INTEL.
productTypeFilter	[]	Optional case-insensitive Shopify product_type filter.
maxProductsPerStore	5000	Maximum catalog products scanned per store. Range: 250–25,000.
maxResults	500	Maximum billable intelligence records delivered in one run. Range: 1–5,000.
maxRuntimeMs	300000	Hard runtime cap in milliseconds. Range: 10,000–3,600,000.
debug	false	Enables additional diagnostic logging.

Store input format

You can provide:

allbirds.com

or:

https://allbirds.com

The Actor normalizes the value to a bare domain.

Duplicate domains are removed.

Invalid values are rejected or reported during input validation.

Example: stricter sale intelligence

{
  "stores": [
    "allbirds.com",
    "colourpop.com"
  ],
  "minDiscountPct": 25,
  "newArrivalWindowDays": 14,
  "maxProductsPerStore": 5000,
  "maxResults": 1000
}

This configuration focuses the sale signal on discounts of at least:

25%

while still returning products published within the last:

14 days

Example: one product type

{
  "stores": [
    "example-store.com"
  ],
  "productTypeFilter": [
    "shoes"
  ],
  "minDiscountPct": 10,
  "newArrivalWindowDays": 30
}

The filter is case-insensitive.

Output

The dataset can contain three record types:

PRODUCT_INTEL STORE_INTEL_SUMMARY RUN_SUMMARY

PRODUCT_INTEL

A billable product intelligence record.

It is written when the product is:

on sale at or above minDiscountPct

and/or:

a new arrival inside newArrivalWindowDays

Plain catalog products with no intelligence signal are not written.

STORE_INTEL_SUMMARY

A free per-store summary.

It can include:

products scanned;

percentage on sale;

median detectable discount;

number of new arrivals;

out-of-stock percentage;

top discounts;

top vendors;

top product types;

pages fetched;

intelligence records detected;

intelligence records delivered.

A store summary also makes a legitimate "nothing found" result visible.

RUN_SUMMARY

A free run-level summary.

It can include:

records written;

billable records;

free records;

stores requested;

stores completed;

stores failed;

unsupported stores;

request counts by store;

quality warnings;

cap reason;

source availability;

store comparison;

operational cost metrics.

Example PRODUCT_INTEL

{
  "recordType": "PRODUCT_INTEL",
  "entityId": "shopify:deathwishcoffee.com/product/7366735200311",
  "store": "deathwishcoffee.com",
  "productId": "7366735200311",
  "handle": "chocolate-hazelnut-16oz-klean-kanteen",
  "title": "Chocolate Hazelnut Klean Kanteen",
  "url": "https://deathwishcoffee.com/products/chocolate-hazelnut-16oz-klean-kanteen",
  "vendor": "Klean Kanteen",
  "productType": "On-The-Go Drinkware",
  "onSale": true,
  "maxDiscountPct": 40,
  "newArrival": false,
  "outOfStock": false,
  "minPrice": 15,
  "maxPrice": 15,
  "variantCount": 1,
  "variantsOnSale": 1,
  "variants": [
    {
      "variantId": "41968903094327",
      "title": "Default Title",
      "sku": "UKCHZL16",
      "price": 15,
      "compareAtPrice": 25,
      "discountPct": 40,
      "available": true
    }
  ],
  "publishedAt": "2026-02-27T08:38:25-05:00",
  "createdAt": null,
  "observedAt": "2026-08-17T05:38:32.990Z"
}

PRODUCT_INTEL output fields

Field	Description
recordType	PRODUCT_INTEL.
entityId	Stable Actor identity composed from store and Shopify product ID.
store	Normalized store domain.
productId	Shopify product ID.
handle	Shopify product handle when available.
title	Product title.
url	Public product URL when a handle is available.
vendor	Shopify vendor field when available.
productType	Shopify product type when available.
onSale	Whether at least one variant meets the minimum discount threshold.
maxDiscountPct	Deepest detectable qualifying variant discount.
newArrival	Whether publishedAt falls inside the configured new-arrival window.
outOfStock	true when no variant is currently marked available.
minPrice	Lowest numeric variant price found.
maxPrice	Highest numeric variant price found.
variantCount	Number of variants in the public product record.
variantsOnSale	Number of variants meeting the configured discount floor.
variants	Variant-level price, compare-at, discount, SKU, title, and availability data.
publishedAt	Shopify product publication timestamp when available.
createdAt	Shopify product creation timestamp when available.
observedAt	Timestamp when the Actor observed the product.

Variant fields

Each item in:

variants[]

can contain:

Field	Description
variantId	Shopify variant ID.
title	Variant title.
sku	SKU when publicly available.
price	Current public variant price.
compareAtPrice	Public compare-at price when available.
discountPct	Calculated discount percentage when computable.
available	Public variant availability flag when available.

New-arrival detection

A product is considered a new arrival when its:

published_at

timestamp falls inside the period ending at the current run time.

For example:

{
  "newArrivalWindowDays": 7
}

means a product must have been published within the previous seven days.

Important

This is based on Shopify's public:

published_at

value.

It is not a historical baseline comparison.

Out-of-stock behavior

A product is considered fully out of stock when it has variants and none of them is marked:

available: true

With:

{
  "includeOutOfStock": false
}

fully sold-out products are excluded from billable intelligence records.

They can still contribute to the free store-level aggregate metrics.

Store summaries

Every successfully processed store receives a free summary.

Example shape:

{
  "recordType": "STORE_INTEL_SUMMARY",
  "store": "example.com",
  "status": "OK",
  "pagesFetched": 4,
  "catalogTruncated": false,
  "intelDelivered": 42,
  "intelDetected": 42,
  "productsScanned": 730,
  "onSaleCount": 85,
  "onSalePct": 11.6,
  "medianDiscountPct": 20,
  "newArrivalsCount": 18,
  "outOfStockPct": 4.8,
  "topDiscounts": [],
  "topVendors": [],
  "topProductTypes": [],
  "observedAt": "2026-08-17T05:38:32.990Z"
}

Portfolio comparison

The free RUN_SUMMARY contains a store comparison derived from successful store summaries.

The comparison can include:

store productsScanned onSalePct medianDiscountPct newArrivalsCount outOfStockPct

This makes the Actor useful as a competitor portfolio snapshot without requiring an external aggregation step.

Password-protected and unsupported stores

The Actor recognizes controlled conditions such as:

STORE_PASSWORD_PROTECTED NOT_SHOPIFY_OR_HEADLESS

These conditions do not automatically crash the entire batch.

The store can be represented by a free summary with a controlled status while other stores continue.

Blocking and source errors

The Actor does not attempt to circumvent access controls.

Conditions such as:

HTTP 403 HTTP 430

are treated as source blocking or unavailable conditions.

Retryable conditions such as:

HTTP 429 HTTP 5xx network failures timeouts

use controlled retry behavior before the run decides the final outcome.

Scheduling

This Actor is useful for repeatable competitive snapshots.

A common cadence is:

daily weekly before a pricing or promotion review

Because every run is self-contained, scheduling does not require a previous baseline.

Recommended scheduled workflow

Configure your competitor store list.

Save the configuration as an Apify Task.

Go to Console → Schedules → Create schedule.

Choose the desired cadence.

Run the Task automatically.

Send results to your preferred destination.

Possible destinations include:

Google Sheets;

Slack;

webhooks;

n8n;

Make;

Zapier;

CRM;

databases;

dashboards;

internal applications.

Example competitor-intelligence workflow

Input

{
  "stores": [
    "competitor-a.com",
    "competitor-b.com",
    "competitor-c.com"
  ],
  "minDiscountPct": 15,
  "newArrivalWindowDays": 14,
  "maxProductsPerStore": 5000,
  "maxResults": 1000
}

Possible downstream flow

The Actor scans each public Shopify catalog.

It writes only products carrying sale or new-arrival intelligence.

Free store summaries compare the competitors.

A downstream workflow can:

rank the deepest discounts;

create a promotion report;

flag new product launches;

save results to a database;

send a Slack alert;

generate an internal summary;

update a dashboard.

The Actor supplies structured public data and deterministic calculations.

Your downstream system decides how to act on them.

Run health

The Actor writes operational information to:

STATS

in the default key-value store.

Depending on the run, this can include:

request counts;

retries;

stores completed;

stores failed;

unsupported stores;

records written;

charged results;

free rows;

warnings;

quality signals;

source-unavailable state;

runtime and cost metrics.

Health and error behavior

The Actor uses controlled error codes instead of silently returning structurally broken data.

Possible conditions include:

INVALID_INPUT HTTP_TIMEOUT HTTP_UNAVAILABLE SOURCE_BLOCKED API_CONTRACT_CHANGED STORE_PASSWORD_PROTECTED NOT_SHOPIFY_OR_HEADLESS ALL_STORES_FAILED

The exact run outcome depends on whether the condition is:

an input problem;

a controlled unsupported-store condition;

a partial store failure;

a source outage;

a terminal contract problem.

API

Run the Actor through the Apify API and receive dataset items programmatically.

Example:

curl -s "https://api.apify.com/v2/acts/<YOUR_USERNAME>~shopify-sale-newarrival-intelligence/run-sync-get-dataset-items?token=<YOUR_TOKEN>"
-X POST
-H "Content-Type: application/json"
-d '{ "stores":["allbirds.com","deathwishcoffee.com"], "minDiscountPct":10, "newArrivalWindowDays":30, "maxResults":500 }'

Replace:

<YOUR_USERNAME> <YOUR_TOKEN>

with your Apify account values.

Integrations

The Actor can be used with:

Apify API;

webhooks;

Apify Tasks;

Apify Schedules;

n8n;

Make;

Zapier;

Google Sheets;

Slack;

databases;

BI tools;

custom applications.

Pricing

This Actor uses Pay Per Event.

The billable result event is:

intel-product

A result is billable only when a PRODUCT_INTEL record is actually delivered.

That means plain catalog products with no qualifying sale or new-arrival signal are not written as billable product intelligence.

The Actor also calls a run-start event:

actor-start

Store summaries and the final run summary are free rows.

The Pricing tab on the Actor page is always the authoritative source for current prices.

What is free

These dataset rows are designed to be free:

STORE_INTEL_SUMMARY RUN_SUMMARY

They provide visibility into:

stores scanned;

zero-result stores;

unsupported stores;

aggregate sale metrics;

new-arrival metrics;

portfolio comparisons;

run quality.

Cost control

The main user-controlled output caps are:

maxResults maxProductsPerStore maxRuntimeMs

You can also reduce billable output by using:

minDiscountPct newArrivalWindowDays productTypeFilter includeOutOfStock

Lower-volume research

Use:

a higher minimum discount;

a shorter new-arrival window;

a narrower product-type filter;

a smaller maxResults.

Broader research

Use:

a lower minimum discount;

a longer new-arrival window;

more stores;

a larger product scan cap.

Honest limits

Sale detection requires public compare-at pricing

If the public Shopify data does not expose a useful:

compare_at_price

the Actor cannot infer a real discount.

This is not a historical price monitor

The Actor does not maintain a customer-visible price baseline for cross-run price changes.

Use the companion Shopify monitor for change events.

It does not scrape private Shopify data

The Actor does not access:

Shopify Admin;

private inventory systems;

customer data;

merchant dashboards;

authenticated APIs.

Exact inventory quantity is not available

The public catalog can expose variant availability.

It does not expose a reliable private inventory count.

Headless storefronts may not support the route

Some Shopify merchants use custom/headless architectures where:

/products.json

is unavailable or does not provide the expected contract.

Those stores can return:

NOT_SHOPIFY_OR_HEADLESS

Password-protected stores are not bypassed

A password-protected storefront is reported as:

STORE_PASSWORD_PROTECTED

The Actor does not attempt to bypass the password.

Catalogs can be truncated by your cap

When a store contains more products than:

maxProductsPerStore

the scan stops at the configured cap.

The store summary exposes:

catalogTruncated

so the limitation is visible.

published_at is the source for new-arrival detection

A product counts as recent according to the public Shopify publication timestamp.

The Actor does not claim that this timestamp is the merchant's internal launch-planning date.

Source behavior can change

Shopify or individual stores can change the behavior of their public storefront endpoints.

The Actor uses health checks and controlled failures to surface unexpected contract changes instead of inventing data.

FAQ

Do I need a Shopify account?

No.

Do I need a Shopify API key?

No.

Does the Actor use the Shopify Admin API?

No.

Does it use browser automation?

No.

Does it need a proxy?

The current implementation uses direct HTTP requests to the public storefront catalog route.

Can I scan multiple stores?

Yes.

The current input accepts up to:

50

store entries per run.

What counts as a sale?

At least one variant must have:

compare_at_price > price

and the calculated discount must meet:

minDiscountPct

Can it detect discount codes?

Not reliably.

Discount-code promotions that are not reflected in public compare-at pricing are outside the current detection contract.

How are new arrivals detected?

Using the public Shopify:

published_at

timestamp and your:

newArrivalWindowDays

setting.

Does it need a baseline?

No.

Does it track price changes between runs?

No.

Use the companion Shopify Price & Catalog Monitor for persistent price, stock, product-added, and product-removed change events.

Can I exclude sold-out products?

Yes.

Use:

{
  "includeOutOfStock": false
}

Can I filter by product type?

Yes.

Use:

{
  "productTypeFilter": [
    "shoes",
    "accessories"
  ]
}

How many products can it scan per store?

The current input supports up to:

25000

products per store.

How many billable results can I allow?

The current maxResults range is:

1–5000

What happens if a store is password-protected?

It receives a controlled:

STORE_PASSWORD_PROTECTED

status.

The rest of the batch can continue.

What happens if a store is headless or not compatible?

It can receive:

NOT_SHOPIFY_OR_HEADLESS

instead of being parsed as valid Shopify data.

What am I charged for?

Billable PRODUCT_INTEL records according to the Actor's Pay Per Event configuration, plus the run-start event shown in the Pricing tab.

Are store summaries charged?

No.

Is the final run summary charged?

No.

Can I schedule this Actor?

Yes.

Because each run is a self-contained snapshot, you can schedule it daily, weekly, or according to your competitive-research workflow.

Is this affiliated with Shopify?

No.

This is an unofficial community Actor and is not affiliated with, sponsored by, or endorsed by Shopify Inc.

Support

Found a bug, a source contract change, or a field this intelligence is missing?

Open an issue on the Actor page or write to johnatan291303@gmail.com — we reply within 24 hours.

Part of the JM Forge suite

Also from the same developer:

Shopify Price & Catalog Monitor — persistent Shopify price, stock, product-added, and product-removed change monitoring across scheduled runs.

Use Shopify Competitor Sale & New Arrival Insights when you need the current competitive picture.

Use Shopify Price & Catalog Monitor when you need historical change events.