# Shopify New Arrivals — Track Product Launches Across Stores (`tidyfeed/shopify-new-arrivals`) Actor

See what a Shopify store launched recently. Point it at a list of brands and get every product published in the last N days, newest first, with price, discount and stock.

- **URL**: https://apify.com/tidyfeed/shopify-new-arrivals.md
- **Developed by:** [tidyfeed](https://apify.com/tidyfeed) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $14.00 / 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/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 New Arrivals — Track Product Launches Across Stores

**Give it a list of brands. Get everything they launched recently, newest first.**

Product, launch date, days old, price, discount, stock — one row each. Run it Monday morning across the brands you watch and read the week in one sheet.

No API key. No login. No Shopify partner account. No proxies.

***

### What a run looks like

Two real stores, read on 2 September 2026 with a 60-day window:

| Store | Catalog scanned | Launched in 60 days |
|---|---|---|
| deathwishcoffee.com | 150 products | **34** |
| kotn.com | 1,297 products | **294** |

Kotn runs a custom front end, so `kotn.com/products.json` answers with a web page and most scrapers stop there. This one found the store's Shopify shop and read the catalog anyway.

***

### What you get

One row per new product, newest first within each store:

**When** — `publishedAt`, `daysSincePublished`, `createdAt`, `updatedAt`

**What** — `productTitle`, `vendor`, `productType`, `tags`, `productUrl`, `imageUrl`, `imageCount`, `skus`

**For how much** — `minPrice`, `maxPrice`, `maxCompareAtPrice`, `discountPercent`, `onSale`

**Available?** — `variantCount`, `availableVariantCount`, `anyAvailable`

Prices arrive as numbers, not strings.

***

### Typical uses

- **Watch a category week by week.** Twenty brands, a 7-day window, every Monday. Launch rate is the clearest signal of which competitors are actually investing.
- **Spot a trend before it is one.** When four brands in a niche launch the same product type in the same fortnight, that is worth knowing early.
- **Check price positioning at launch.** New products carry a brand's current view of what a category is worth — clearer than a catalog full of legacy prices.
- **Catch a competitor entering your category.** A brand's first product of a new `productType` shows up as a row.

***

### Input

| Field | What it does |
|---|---|
| `storeUrls` | The brands to watch. Normal website addresses. |
| `daysBack` | The window. 7 for a weekly check, 30 for a monthly one. Default 30. |
| `maxProductsScanned` | Cap on how much of each catalog is read. Default 5,000. |
| `onlyAvailable` | Drop launches that are already sold out. |
| `includeDescription` | Add the description as plain text. |

***

### What it costs

**Billed per new product delivered.** A quiet store returns nothing and costs nothing beyond the run start — you are not charged for a week where nobody launched anything, even though the catalog still had to be read.

Platform usage is included. No proxies are needed, so there are no proxy costs.

***

### How it works

Shopify serves a public product feed at `/products.json` on every storefront, and every product in it carries the date the store published it. This actor walks that feed 250 products at a time, keeps only the ones inside your window, and discards the rest as it goes — so memory tracks how many launches there were, not how large the store is.

**Headless storefronts are followed to their real shop.** Brands running a custom front end answer `/products.json` with a web page. This actor reads the shop address the site publishes in its own markup and reads the catalog from there.

No HTML parsing means a theme change cannot break it.

***

### Honest limits

Worth knowing before you run it:

- **The whole catalog has to be read to find the new part of it.** Shopify's feed cannot be filtered by date, so a large store takes longer than a small one. The run reports when it hits the scan cap so you know the window was not fully covered.
- **`publishedAt` is when the store published the record, not when the product was designed.** A product migrated between platforms, re-created, or moved from draft to live carries a fresh date. Cross-check anything surprising against the product page.
- **A product removed and re-added looks like a launch.** There is no way to tell those apart from outside.
- **Stock is what the feed publishes, from the United States.** Shopify exposes an in-stock flag per variant, never a quantity, and for stores running separate regional markets that flag reflects the market the request lands in. Runs here originate from US servers. Prices and dates are unaffected.
- **Currency is not published in the feed**, so prices are plain numbers in the store's own currency.
- **Products with no publish date are skipped** and counted in the log rather than guessed at.
- **Password-protected and pre-launch stores return nothing**, with a reason per store.

***

### Scheduling

This actor is built to be scheduled. Point it at a competitor list, set the window to match the interval, and each run leaves a dated record of who shipped what. Weekly is the useful cadence for most categories.

Pair it with `tidyfeed/shopify-store-report` for the wider picture — catalog size, price range and discount depth per store — and `tidyfeed/shopify-product-scraper` when one store turns out to be worth a full read.

***

### Legal

This actor reads only data a Shopify store publishes publicly, at addresses the store itself serves to anyone. It collects no personal data, requires no login, and bypasses no access control. You remain responsible for how you use the exported data.

***

Questions, or a store that behaves oddly? Open an issue on the actor — issues are read and answered.

# Actor input Schema

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

The brands to watch. Paste normal website addresses — https://gymshark.com. No API key, login or Shopify partner account is needed. Stores running a custom front end are resolved to their Shopify shop automatically.

## `daysBack` (type: `integer`):

Only return products the store published inside this window. 7 for a weekly check, 30 for a monthly one.

## `maxProductsScanned` (type: `integer`):

The whole catalog has to be read to find the new part of it. This caps that read. Raise it for stores with very large catalogs — the run will say so when it hits the cap.

## `onlyAvailable` (type: `boolean`):

Leave out launches with no variant in stock. Note that stock is reported for the region the run happens from, which is the United States.

## `includeDescription` (type: `boolean`):

Add the product description as plain text. Off by default because it makes spreadsheets hard to read.

## Actor input object example

```json
{
  "storeUrls": [
    "https://gymshark.com",
    "https://allbirds.com",
    "https://deathwishcoffee.com"
  ],
  "daysBack": 30,
  "maxProductsScanned": 5000,
  "onlyAvailable": false,
  "includeDescription": false
}
```

# Actor output Schema

## `newArrivals` (type: `string`):

No description

## `newArrivalsCsv` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "storeUrls": [
        "https://gymshark.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("tidyfeed/shopify-new-arrivals").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "storeUrls": ["https://gymshark.com"] }

# Run the Actor and wait for it to finish
run = client.actor("tidyfeed/shopify-new-arrivals").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 '{
  "storeUrls": [
    "https://gymshark.com"
  ]
}' |
apify call tidyfeed/shopify-new-arrivals --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tidyfeed/shopify-new-arrivals"
        }
    }
}

```

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/kAHKdcpm3L7VcUhPF/builds/a24ARlJb8oQIxmyJD/openapi.json