# Shopify Price Tracker (`arched_friend/shopify-price-tracker`) Actor

Track competitor prices across any Shopify store. Returns every product and variant with its current price, discount and stock, and flags every price drop, rise and new listing since your last run.

- **URL**: https://apify.com/arched\_friend/shopify-price-tracker.md
- **Developed by:** [Peach O](https://apify.com/arched_friend) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$20.00 / 1,000 store checkeds

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 Price Tracker: Watch Competitor Prices Daily

Point it at any Shopify store and get every product, every variant and every price. Run it again tomorrow and it tells you exactly what moved: which prices dropped, which rose, and what is new in the catalogue.

Built for ecommerce teams, brand managers and resellers who need to know about a competitor's price change on the day it happens, not the week after.

### How it works

```mermaid
flowchart LR
    A["Store domains"] --> B["Read /products.json"]
    B --> C["One row per variant"]
    C --> D{"Compare with<br/>last run"}
    D -->|cheaper| E["price drop"]
    D -->|dearer| F["price rise"]
    D -->|unseen| G["new"]
    E --> H[("Alert rows")]
    F --> H
    G --> H
```

Shopify publishes a product feed on every storefront, so there is no page rendering and nothing to break when a theme changes. That makes runs fast, cheap and reliable.

### Built for

- **Brand and pricing teams** watching how rivals price the same category
- **Resellers and dropshippers** catching restocks and markdowns early
- **Retail analysts** tracking discount depth across a season
- **Agencies** reporting competitor moves to ecommerce clients

### Input

```json
{
  "storeUrls": ["gymshark.com", "alphalete.com"],
  "onlyChanged": true,
  "onlyOnSale": true,
  "minDiscount": 20
}
```

| Setting | What it does |
| --- | --- |
| `storeUrls` | Any Shopify storefront domain |
| `onlyChanged` | Return only drops, rises and new products. Turn on for scheduled runs |
| `onlyOnSale` / `minDiscount` | Focus on real markdowns |
| `minPrice` / `maxPrice` | Stay inside a price band |
| `titleContains` / `vendors` | Narrow to a product line or brand |

### Output

```json
{
  "store": "gymshark.com",
  "title": "Relay Sports Bra",
  "variantTitle": "M",
  "sku": "A2",
  "price": 39.0,
  "compareAtPrice": 55.0,
  "discountPercent": 29.1,
  "onSale": true,
  "available": true,
  "previousPrice": 44.0,
  "priceChange": -5.0,
  "changePercent": -11.4,
  "changeType": "price-drop",
  "url": "https://gymshark.com/products/relay-sports-bra",
  "checkedAt": "2026-09-04T09:14:02.115Z"
}
```

`changeType` is the field to filter on. It is one of `price-drop`, `price-rise`, `new`, `unchanged` or `first-run`.

### Turn it into a daily alert

Set `onlyChanged` to true and schedule it every morning. The first run records the baseline and returns everything. Every run after that returns only what actually moved, which is usually a handful of rows you can read over coffee.

```json
{
  "storeUrls": ["competitor-one.com", "competitor-two.com"],
  "onlyChanged": true
}
```

### Run it as an API

```bash
curl -X POST "https://api.apify.com/v2/acts/arched_friend~shopify-price-tracker/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "storeUrls": ["gymshark.com"],
    "onlyOnSale": true,
    "minDiscount": 30
  }'
```

### Pricing

You pay $0.02 for each store checked, however many products it holds. A store with 5,000 products costs the same as one with 50.

| Watching 10 competitor stores daily | Monthly cost |
| --- | --- |
| Checking by hand | roughly 20 hours |
| Most price monitoring suites | $99 to $500 per month |
| This Actor | $6 per month |

### Common questions

**How do I know a store is on Shopify?** Open `thatstore.com/products.json` in a browser. If you see JSON, it works. Tech Stack Checker will tell you across a whole list at once.

**Does it see every product?** It reads the public catalogue feed, which is what the storefront itself uses. Products hidden from the storefront are not in it.

**Where is the price history kept?** Each run stores the prices it saw and compares the next run against them, so history builds up automatically from your first run onward.

### Related products

- **Tech Stack Checker** to find which of your competitors run Shopify in the first place
- **Website Lead Extractor** to pull contact details for the brands you find
- **Google Maps Lead Finder** to build a list of local retailers to check
- **Lead Enrichment Pipeline** to turn any domain list into qualified rows

# Actor input Schema

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

Store domains or URLs, one per line. Anything on a Shopify storefront works, for example gymshark.com.

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

Upper limit on how many products to read from each store.

## `onlyChanged` (type: `boolean`):

Return only price drops, price rises and new products. Turn this on for scheduled monitoring so each run is a short alert list rather than the whole catalogue.

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

Keep only variants that are currently in stock.

## `onlyOnSale` (type: `boolean`):

Keep only products priced below their compare at price.

## `minPrice` (type: `integer`):

0 means no minimum.

## `maxPrice` (type: `integer`):

0 means no maximum.

## `minDiscount` (type: `integer`):

Keep only products discounted by at least this much.

## `titleContains` (type: `array`):

Keep only products whose title contains one of these words.

## `vendors` (type: `array`):

Keep only these vendor names.

## `proxyConfiguration` (type: `object`):

Optional. Useful when tracking many stores on a schedule.

## Actor input object example

```json
{
  "storeUrls": [
    "gymshark.com"
  ],
  "maxProductsPerStore": 1000,
  "onlyChanged": false,
  "onlyAvailable": false,
  "onlyOnSale": false,
  "minPrice": 0,
  "maxPrice": 0,
  "minDiscount": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One row per product variant, with price, discount, stock and what changed since the last run.

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

Per store counts of products read, price drops, price rises and new listings.

# 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": [
        "gymshark.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("arched_friend/shopify-price-tracker").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": ["gymshark.com"] }

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

```

## MCP server setup

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

```

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/XDq9KAZEqeAnCOqno/builds/kqgcMXJWV0kvGPNe7/openapi.json