# Shopify Competitor Sale & New Arrival Insights (`johnatan029/shopify-sale-newarrival-intelligence`) Actor

Track public Shopify stores for competitor sales and new arrivals. Detect variant-level discounts, recent product launches, out-of-stock signals, sale rates, top discounts, and store-level comparisons. Export structured data for pricing research, dashboards, APIs, and automation.

- **URL**: https://apify.com/johnatan029/shopify-sale-newarrival-intelligence.md
- **Developed by:** [Johnn Mottin](https://apify.com/johnatan029) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 intelligence products

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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 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

```json
{
  "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

```json
{
  "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

```json
{
  "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

```json
{
  "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:

```json
{
  "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:

```json
{
  "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:

```json
{
  "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

```json
{
  "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:

```json
{
  "includeOutOfStock": false
}
```

Can I filter by product type?

Yes.

Use:

```json
{
  "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.

# Actor input Schema

## `stores` (type: `array`):

Shopify store domains (e.g. allbirds.com). Password-protected or headless stores come back as a controlled status, never crash the batch.

## `minDiscountPct` (type: `integer`):

A product only counts as on sale when some variant is discounted at least this much vs compare-at price. Floor against price noise.

## `newArrivalWindowDays` (type: `integer`):

A product counts as a new arrival when it was published within this many days.

## `includeOutOfStock` (type: `boolean`):

When off, products with no available variant are excluded from intelligence records (they still count in the free store aggregates).

## `productTypeFilter` (type: `array`):

Case-insensitive product\_type filter. Empty = no filter. Filters narrow the output, never the detection.

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

Catalog read cap per store (250 per page).

## `maxResults` (type: `integer`):

Hard cap on charged intelligence records. The run stops gracefully and keeps what it delivered.

## `maxRuntimeMs` (type: `integer`):

Hard time cap. The run stops gracefully when reached.

## `debug` (type: `boolean`):

Log pacing waits and per-store decisions.

## Actor input object example

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

# Actor output Schema

## `results` (type: `string`):

Default dataset containing PRODUCT\_INTEL, STORE\_INTEL\_SUMMARY, and RUN\_SUMMARY records.

## `stats` (type: `string`):

Operational STATS record with request counts, billing counters, health signals, warnings, and run quality information.

# 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 = {
    "stores": [
        "allbirds.com",
        "deathwishcoffee.com"
    ],
    "minDiscountPct": 5,
    "newArrivalWindowDays": 30,
    "includeOutOfStock": true,
    "productTypeFilter": [],
    "maxProductsPerStore": 5000,
    "maxResults": 500,
    "maxRuntimeMs": 300000,
    "debug": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("johnatan029/shopify-sale-newarrival-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 = {
    "stores": [
        "allbirds.com",
        "deathwishcoffee.com",
    ],
    "minDiscountPct": 5,
    "newArrivalWindowDays": 30,
    "includeOutOfStock": True,
    "productTypeFilter": [],
    "maxProductsPerStore": 5000,
    "maxResults": 500,
    "maxRuntimeMs": 300000,
    "debug": False,
}

# Run the Actor and wait for it to finish
run = client.actor("johnatan029/shopify-sale-newarrival-intelligence").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 '{
  "stores": [
    "allbirds.com",
    "deathwishcoffee.com"
  ],
  "minDiscountPct": 5,
  "newArrivalWindowDays": 30,
  "includeOutOfStock": true,
  "productTypeFilter": [],
  "maxProductsPerStore": 5000,
  "maxResults": 500,
  "maxRuntimeMs": 300000,
  "debug": false
}' |
apify call johnatan029/shopify-sale-newarrival-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,johnatan029/shopify-sale-newarrival-intelligence"
        }
    }
}

```

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/3rvh0yfW4j4uAr7hU/builds/g0FBh2azbzPI8gLWW/openapi.json