# Shopify Price & Restock Monitor for Variants (`vdb997/shopify-price-restock-watch`) Actor

Track Shopify product prices and variant restocks. Export before/after prices, percentage changes, sold-out events and public availability. Persistent watches, failure-safe snapshots and one clear fee per successful product check. No login or API key.

- **URL**: https://apify.com/vdb997/shopify-price-restock-watch.md
- **Developed by:** [Victor Diaz](https://apify.com/vdb997) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 product checks

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?

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 Price & Restock Monitor for Variants

Watch specific Shopify products for price drops, price increases, restocks and sold-out variants. Each variant includes its previous price, current price, currency, percentage change and public availability. Use the dataset with Apify schedules, webhooks, n8n, Make or your own application.

This is a targeted product monitor: paste product URLs instead of crawling an entire catalog. One successful product check includes all variants returned by Shopify, up to its 250-variant response limit.

### Who this is for

**Shopify competitor prices and restock tracking.** Use the Shopify price tracker for a short list of products you actually follow. Compare variant prices and public availability across runs, then send returned changes into a restock feed or competitor-pricing workflow. Availability is what the public endpoint reports, not a stock-quantity estimate.

### Quick start

1. Paste 1–50 public Shopify product URLs into **Shopify product URLs**.
2. Run with **All current records** for an immediate export.
3. To monitor, choose a **Watch ID**, reuse it on future runs and select **Changes only**. The first run saves a baseline without variant alerts; later runs return new variants and changed variants. Every check also returns a summary.

```json
{
  "productUrls": ["https://www.allbirds.com/products/mens-tree-runners-kaikoura-white"],
  "watchId": "competitor-footwear",
  "outputMode": "changes"
}
```

The example product is a public source for testing. Its continued availability is not guaranteed.

### Output

Filter `recordType=variant` for product data; `check_summary` reports check health, counts and variant IDs missing from the latest response. `source_error` explains failed checks. `SUMMARY` in the run's key-value store lists all checks and whether the spending limit stopped the run.

Illustrative changed-variant record:

```json
{
  "recordType": "variant",
  "title": "Example sneaker",
  "variantTitle": "Size 9",
  "variantId": "123456",
  "currency": "USD",
  "priceRaw": 8000,
  "previousPriceRaw": 10000,
  "priceChangePercent": -20,
  "available": true,
  "previousAvailable": false,
  "changeType": "changed",
  "events": ["price_drop", "restocked"]
}
```

Prices ending in `Raw` are the integer monetary values returned by Shopify's Ajax API. For USD, 8000 means $80.00. Preserve the currency and apply its storefront formatting rules; do not assume every currency uses two decimal places. Currency is checked through the public locale-aware `cart.js` endpoint. A currency change is reported separately and never treated as a price drop or increase.

`available` means Shopify exposes the variant as available to purchase. It is not an inventory quantity or proof of sales. This Actor does not estimate revenue or units sold. `compareAtPriceRaw` is the published reference price, when present. Subscription/selling-plan prices are outside the scope.

### Pricing

**$0.01 per successfully checked product**, plus **$0.00005 per run start** at the fixed 512 MB memory setting. Platform usage is included in the event price. All returned variants and summary rows are included; there is no per-row fee.

A successful unchanged or sold-out product still counts as a check. Failed requests and unsupported products do not trigger a product-check charge. Set **Maximum cost per run** to cap spending; the Actor checks the remaining event budget before requesting the next product.

Examples: 10 products checked once cost $0.10005. Checking those 10 products daily for 30 days costs $3.0015. These are buyer costs, not developer earnings.

### Tracking and limitations

- Use non-overlapping schedules for the same Watch ID. Persistent snapshots live in a named key-value store in the caller's account. A new ID starts a new baseline.
- Failed checks never replace the last successful snapshot. A 404 or blocked request is an error, not a sold-out signal.
- Removed variant IDs appear in the summary as missing, not as a claim that an item was discontinued. When Shopify returns 250 variants, `variantLimitReached` warns that the source may be truncated.
- Supports public Shopify theme storefronts and optional locale prefixes such as `/en-us/products/handle`. Store homepages, non-Shopify stores, password-protected stores and custom headless storefronts are unsupported. No login, cookies, API key or proxy is required.
- The Actor reads public JSON endpoints with bounded requests. It does not bypass access controls. Geo-dependent prices can differ from a customer's browser; reuse the same locale URL for consistent comparisons.

Source reference: [Shopify Ajax Product API](https://shopify.dev/docs/api/ajax/reference/product).

For hiring signals, see [ATS Job Watch](https://apify.com/vdb997/ats-job-watch). For new articles by keyword, see [Google News Keyword Watch](https://apify.com/vdb997/google-news-keyword-watch).

### Try one source before scheduling

1. Open the Input tab and use one supported source with `outputMode: "all"` for an immediate export.
2. Check the returned records and the check summary. Confirm the source, coverage and price suit your workflow.
3. To monitor, set a stable Watch ID and `outputMode: "changes"`. The first successful run establishes a silent baseline.
4. Reuse that Watch ID on later runs. A summary without change records means the check completed without matching changes.
5. Add an Apify schedule after the manual checks work. Avoid overlapping runs with the same Watch ID. Use Maximum cost per run to cap event charges.

Public-data monitors by the same developer: [browse the catalog](https://apify.com/vdb997).

# Actor input Schema

## `productUrls` (type: `array`):

1–50 public Shopify product URLs, including optional locale prefixes. Store homepages and custom headless storefronts are not supported.

## `watchId` (type: `string`):

Reuse an ID to keep snapshots in your account. Leave blank for a one-off extraction. Use a new ID to reset; do not run the same watch concurrently.

## `outputMode` (type: `string`):

Changes mode establishes a silent baseline on the first run. Check summaries and source errors are always included.

## Actor input object example

```json
{
  "productUrls": [
    "https://www.allbirds.com/products/mens-tree-runners-kaikoura-white"
  ],
  "outputMode": "all"
}
```

# Actor output Schema

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

No description

## `summary` (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 = {
    "productUrls": [
        "https://www.allbirds.com/products/mens-tree-runners-kaikoura-white"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("vdb997/shopify-price-restock-watch").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 = { "productUrls": ["https://www.allbirds.com/products/mens-tree-runners-kaikoura-white"] }

# Run the Actor and wait for it to finish
run = client.actor("vdb997/shopify-price-restock-watch").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 '{
  "productUrls": [
    "https://www.allbirds.com/products/mens-tree-runners-kaikoura-white"
  ]
}' |
apify call vdb997/shopify-price-restock-watch --silent --output-dataset

```

## MCP server setup

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

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/Z67CapLn5WkdRWwdW/builds/fAe4yQF8Rhc3abtim/openapi.json