# Datavoryx – Shopify Price & Stock Monitor (`soruvalab/datavoryx-shopify-price-stock-monitor`) Actor

Monitor Shopify product prices, stock availability, and competitor pricing. Detect price drops, price increases, and restocks. Track persistent price history, set custom price thresholds, and receive automated Discord alerts when changes occur.

- **URL**: https://apify.com/soruvalab/datavoryx-shopify-price-stock-monitor.md
- **Developed by:** [SoruvaLab](https://apify.com/soruvalab) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.70 / 1,000 results

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?

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

## Datavoryx — Shopify Price & Stock Monitor

**Track Shopify competitor prices, monitor stock availability, and catch important product changes — without manually checking every store.**

Datavoryx helps ecommerce sellers, pricing analysts, and market research teams monitor publicly accessible Shopify product data across multiple stores.

**Know what changed, when it changed, and which products deserve your attention.**

- **Catch price drops and increases** across monitored Shopify stores.
- **Spot restocks and sold-out variants** before your next manual check.
- **Compare competitor offers** using available product, variant, and barcode information.
- **Track changes over time** with persistent monitoring history.
- **Get optional Discord alerts** for qualifying price and availability changes.
- **Export structured results** for reporting, analysis, and automation.

**No Shopify admin credentials required. No manual product-by-product checking.**

#### How It Works

1. Add up to 10 public Shopify store URLs.
2. Choose how many products to monitor per store.
3. Set a unique Monitor ID for tracking history.
4. Run your first scan to establish a baseline.
5. Run again with the same Monitor ID to detect price and stock changes.
6. Review Dataset results, monitoring reports, and optional Discord alerts.

For recurring checks, use Apify Schedules.

**Note:** Product coverage depends on each store's publicly accessible data. Datavoryx performs scheduled snapshots, not continuous real-time monitoring.

### Key Features

- **Price Change Detection** — Identify price drops and increases between monitoring runs.
- **Stock Availability Monitoring** — Detect when variants return to stock or become unavailable.
- **Variant-Level Tracking** — Monitor individual product variants rather than product-level prices alone.
- **Competitor Price Comparison** — Compare offers across Shopify stores using normalized product names and variant details or matching barcodes.
- **Smart Discord Alerts** — Receive notifications for qualifying price changes and stock events.
- **Configurable Alert Thresholds** — Reduce unnecessary price notifications by setting a minimum percentage change.
- **Persistent Monitoring History** — Compare current observations with historical snapshots.
- **Structured Dataset Export** — Access product and variant observations for analysis.
- **Monitoring Reports** — Review changes, summary statistics, and competitor comparisons.

### Example Input

```json
{
  "shopUrls": [
    "https://www.allbirds.com",
    "https://www.tentree.com"
  ],
  "maxProducts": 10,
  "monitorId": "competitor-monitor-01",
  "minPriceChangePercent": 5,
  "alertOnPriceDrops": true,
  "alertOnPriceIncreases": true,
  "productSearch": ""
}
```

The example store URLs are illustrative. Availability of public product endpoints depends on each store.

### Input Parameters

| Parameter | Description |
|---|---|
| `shopUrls` | Public Shopify store homepage URLs; 1–10 stores per run. |
| `maxProducts` | Maximum products checked per store, from 1 to 250. |
| `monitorId` | Identifier used to associate repeated runs with the same monitoring history. |
| `discordWebhookUrl` | Optional Discord webhook URL for change notifications. |
| `minPriceChangePercent` | Minimum percentage change required for price alerts. |
| `alertOnPriceDrops` | Enable notifications for qualifying price decreases. |
| `alertOnPriceIncreases` | Enable notifications for qualifying price increases. |
| `productSearch` | Optional product name, barcode, or SKU filter for competitor comparison. |

Use the same Monitor ID for subsequent runs that should share a monitoring history.

### Price and Stock Change Detection

Datavoryx compares product observations between runs to identify:

- `FIRST_SEEN` — A variant is observed for the first time.
- `PRICE_DROP` — The current price is lower than the previous price.
- `PRICE_INCREASE` — The current price is higher than the previous price.
- `BACK_IN_STOCK` — A previously unavailable variant becomes available.
- `OUT_OF_STOCK` — A previously available variant becomes unavailable.
- `NO_CHANGE` — No tracked change is detected.

A variant can experience more than one change type during a comparison.

### Competitor Price Comparison

Datavoryx can compare product offers across different Shopify stores.

Supported matching methods include:

**Product and variant matching**

Products are compared using normalized product names and variant information, including available size and width details.

**Barcode matching**

When compatible barcode information is available, Datavoryx can identify matching products across stores.

Competitor comparison results can include matching methods, store information, variant details, prices, and price differences.

Comparisons depend on the quality of publicly available product data. Product-name matching is not a guarantee that two listings represent identical items.

### Example Output

The following example is based on an actual Datavoryx monitoring run against publicly accessible Allbirds product data.

```json
{
  "store": "https://www.allbirds.com",
  "currency": "USD",
  "productTitle": "Women's Allbirds Flip Flop - Dusty Pink",
  "variantTitle": "10",
  "sku": "A12513W100",
  "price": 25,
  "previousPrice": null,
  "priceChange": null,
  "available": true,
  "previousAvailable": null,
  "status": "FIRST_SEEN",
  "checkedAt": "2026-10-27T09:10:30.189Z"
}
```

#### What This Data Tells You

- **Product-level visibility:** Identify which Shopify products are being monitored.
- **Variant-level stock tracking:** Check availability for individual sizes or variants.
- **Structured pricing data:** Capture publicly listed prices and currencies.
- **Historical comparisons:** On the first run, `FIRST_SEEN` establishes the baseline. Subsequent runs with the same Monitor ID can detect qualifying price and availability changes.

For example, in this observation, size 10 of the selected product was available at $25 USD, while other sizes had different availability statuses.

**Note:** This is a real first-observation example, not a simulated price-change event. Public product data and availability can change over time.

### Output Data

Datavoryx writes product and variant observations to the Apify Dataset.

Available fields can include:

- Store and product information
- Product and variant identifiers
- Product URL
- Current and previous prices
- Price changes
- Current and previous stock availability
- Change status
- Observation timestamp

You can use Apify's export options to retrieve the available Dataset results.

### Monitoring Reports

Datavoryx generates monitoring reports in its default Key-value store.

**`SUMMARY`**

Provides an overview of the monitoring run, including processed stores, product and variant counts, detected changes, notification activity, and errors.

**`CHANGE_REPORT`**

Summarizes detected price and availability changes.

**`COMPETITOR_PRICE_REPORT`**

Contains competitor price comparison results where suitable cross-store matches are identified.

These reports can be reviewed without configuring Discord.

### Discord Notifications

Datavoryx supports optional Discord webhook notifications.

Notifications may include product details, change type, previous and current prices, and product links.

You can configure a minimum price-change percentage to reduce unnecessary price alerts. Stock alerts are handled separately from the price-change threshold.

Discord delivery depends on the availability of the configured webhook and Discord's service.

**Security:** Treat Discord webhook URLs as confidential credentials. Only use webhooks that you own or are authorized to manage.

### Pricing

Datavoryx uses Apify's **Pay per event** pricing model. A **Result** event is charged for each item written to the default dataset.

The following prices were configured on **November 4, 2026**:

| Apify customer plan | Price per 1,000 results |
|---|---:|
| Free (no discount) | $2.00 |
| Starter (Bronze discount) | $1.90 |
| Scale (Silver discount) | $1.80 |
| Business (Gold discount) | $1.70 |

- **Actor Start:** $0.00005 per start event. The number of start events depends on the memory allocated to the run.
- **Platform usage:** Included in customer-facing event prices. No separate platform usage charge is added to customers.
- **Billing:** Total charges depend on the number of billable results, applicable start events, and the customer's Apify subscription plan.
- **Repeated monitoring:** Each monitoring run can generate additional billable Dataset results.

For the latest rates, check the **Pricing** section on the [Datavoryx Apify Store page](https://apify.com/soruvalab/datavoryx-shopify-price-stock-monitor).

### Important Limitations

- Datavoryx uses publicly accessible Shopify product information.
- Some stores restrict access to product endpoints or do not expose compatible data.
- Product coverage is limited by store availability and the configured maximum product count.
- Public prices may exclude shipping, taxes, regional adjustments, and personalized discounts.
- Competitor comparisons depend on matching product and variant information.
- Matching products by name or variant is not always sufficient to establish exact product identity.
- Monitoring runs are snapshots, not continuous real-time surveillance.
- Changes occurring between runs may not be captured.
- Historical comparisons require accessible monitoring history and consistent monitor identifiers.
- External notification delivery is subject to Discord availability.

### Common Use Cases

**Ecommerce Price Intelligence**

Track publicly listed prices across selected Shopify stores and identify meaningful movements.

**Competitor Benchmarking**

Compare similar or matching products across stores to identify pricing differences.

**Inventory Monitoring**

Identify products and variants that return to stock or become unavailable.

**Market Research**

Collect structured product observations for analysis and reporting.

**Automated Monitoring Workflows**

Use Apify Schedules and downstream integrations to support recurring monitoring and analysis.

### Frequently Asked Questions

**Do I need Shopify API credentials?**

No. Datavoryx works with publicly accessible product information.

**Does the first run detect historical changes?**

No. The first run normally establishes a baseline for subsequent comparisons.

**Can I use Datavoryx without Discord?**

Yes. You can review Dataset results and monitoring reports without enabling notifications.

**Does Datavoryx run continuously?**

No. Each run checks the selected stores at that time. Schedule repeated runs for ongoing monitoring.

**Can it monitor every Shopify store?**

No. Some stores restrict public product endpoints or use incompatible configurations.

**Does competitor comparison guarantee identical products?**

No. Barcode matching can provide stronger identification when reliable barcodes are available, while name-and-variant matching should be interpreted as a comparison candidate.

***

**Datavoryx — Turn Shopify product observations into actionable price, inventory, and competitor intelligence.**

# Actor input Schema

## `shopUrls` (type: `array`):

Enter 1 to 10 public Shopify store homepage URLs. Use HTTPS addresses without additional paths or query parameters.

## `maxProducts` (type: `integer`):

Number of products to check per store, from 1 to 250. Higher limits may increase processing time.

## `monitorId` (type: `string`):

Optional when using Discord. Use a unique ID to keep monitoring histories separate. Keep the same ID for subsequent runs of the same monitor.

## `discordWebhookUrl` (type: `string`):

Receive Discord notifications when prices or stock availability change. Leave blank to use Dataset and monitoring reports without Discord. A Monitor ID is required when Discord is not configured.

## `minPriceChangePercent` (type: `integer`):

Minimum absolute percentage change required for Discord price alerts. Set to 0 to alert on every price change. Stock alerts are unaffected.

## `alertOnPriceDrops` (type: `boolean`):

Send Discord alerts when prices decrease by at least the configured percentage.

## `alertOnPriceIncreases` (type: `boolean`):

Send Discord alerts when prices increase by at least the configured percentage.

## `productSearch` (type: `string`):

Enter a product name, barcode, or SKU to filter products for competitor price comparison.

## `sendDiscordTestMessage` (type: `boolean`):

Send a test message to verify the configured Discord webhook.

## `testPriceStockAlerts` (type: `boolean`):

Send simulated price-drop and back-in-stock messages to Discord.

## `isolatedChangeTest` (type: `boolean`):

Test price and stock change detection without opening or modifying monitoring history. Sends simulated Discord alerts when a webhook is configured.

## Actor input object example

```json
{
  "shopUrls": [
    "https://www.allbirds.com"
  ],
  "maxProducts": 100,
  "minPriceChangePercent": 5,
  "alertOnPriceDrops": true,
  "alertOnPriceIncreases": true,
  "productSearch": "",
  "sendDiscordTestMessage": false,
  "testPriceStockAlerts": false,
  "isolatedChangeTest": false
}
```

# Actor output Schema

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

Product and variant prices, stock availability, and detected changes.

## `summary` (type: `string`):

Monitoring status, checked products and variants, and notification statistics.

## `changeReport` (type: `string`):

Detected price and stock changes, including totals by change type.

# 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 = {
    "shopUrls": [
        "https://www.allbirds.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("soruvalab/datavoryx-shopify-price-stock-monitor").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 = { "shopUrls": ["https://www.allbirds.com"] }

# Run the Actor and wait for it to finish
run = client.actor("soruvalab/datavoryx-shopify-price-stock-monitor").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 '{
  "shopUrls": [
    "https://www.allbirds.com"
  ]
}' |
apify call soruvalab/datavoryx-shopify-price-stock-monitor --silent --output-dataset

```

## MCP server setup

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

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/wvU9s1tNqeqlqFXGK/builds/RK63ujNNkLJoQ80Oh/openapi.json