Competitor Price Tracker & Stock Monitor | PAL

For price monitoring teams: use this competitor price tracker to compare published product prices and stock-label changes across repeated runs. It exports alert signals for your integrations, but does not send notifications by itself.

New here? Try one price check with Apify Free

Start with your existing Apify Free-plan credits — no payment card required to sign up. Apify currently includes USD 5 of monthly usage credit in its Free plan; this Actor still charges usage events against available credit, so it is not an unlimited free service. For one successful priced product check, the example event fees are USD 0.00355 (USD 0.00005 run start + USD 0.0035 product-check), before any other applicable costs. Read the live Pricing tab and your remaining credit before running.

1. Open this Actor and select Try for free. Keep the prefilled public synthetic product URL.
2. Press Start once and inspect the first result in Dataset — no retailer account, API key, or personally identifying data required for this sample.
3. Replace the sample URL with your own public product page only after checking that it exposes static Product JSON-LD or product-typed Open Graph price metadata. The Actor does not automatically email alerts or render JavaScript-only prices.

Want to inspect the setup first? Open the existing public Example task.

Stop comparing competitor product pages by hand. Save a baseline from public ecommerce pages, run the same monitor again and export exactly which published prices and stock labels changed.

Built for ecommerce pricing analysts, marketplace operators, catalog managers and developers who want repeatable, structured competitor intelligence.

Preview the example before an Apify run: Review the prefilled sample product URL and JSON input in the sections below before running anything. The example can be viewed without triggering a priced event; actual Actor starts incur the prices in the live Pricing tab.

Estimate time saved on repetitive manual checks

Every product-page comparison that a team performs manually takes time. Estimate your own possible labor savings using your product URL count, checks per week, minutes per page, human-review time, setup time and labor value. Compare those assumed hours against the example event fees below. These are hypothetical assumptions, not measured customer savings or guaranteed ROI. The Actor only checks public static metadata and still requires human review. Always check the live Pricing tab before running.

What you get

• Price changes over time: current and previous published prices, absolute delta and percentage change.
• Published availability-label changes: compare InStock and OutOfStock-style values found in Product JSON-LD. This does not verify warehouse or checkout stock.
• Actionable change flags: eventType, changed, alertSignal, alertKind and alertReason.
• Your own threshold: set minPriceChangePercent, e.g. 5%, for material price movements.
• Persistent comparison baseline: reuse the same monitorId on later runs.
• Exportable dataset: JSON or CSV results that can feed your own reports, dashboard, Apify API automation or webhook.
• Up to 50 public HTTPS product URLs per run, extracting up to 20 Product JSON-LD offers (or one eligible Open Graph product) per page.

Supported product-page data

The Actor first looks for schema.org Product JSON-LD. If there is no Product JSON-LD, it can use explicitly product-typed Open Graph product price tags (og:type=product or product.item) together with a product title, numeric amount and three-letter currency code. General articles and pages with only a title are not treated as products.

The metadataSource output field identifies product_jsonld or open_graph_product. Open Graph fallback returns one product per page, so it does not claim support for all variants or multiple sellers unless the page exposes Product JSON-LD. No JavaScript rendering, Amazon scraping, login, checkout stock verification or currency conversion is implied.

Both supported sources use the same pay-per-event rule: a successfully extracted product with a published price triggers one product-check charge, including a repeated unchanged price observation. The Actor never bills an extra event just because both JSON-LD and Open Graph tags exist.

Compare competitor prices with your own on the first run

You do not need to wait for a second run to see a useful comparison. Add the optional referencePrices JSON object, mapping each exact source page URL to your own published reference price and its three-letter currency. This feature is useful for an ecommerce pricing team checking whether a competitor's advertised price is above or below its own.

For example, this entirely fictitious public demo publishes a USD 39.90 Open Graph product price. Compare it against your own sample USD 45.00:

{
  "urls": [
    "https://api.apify.com/v2/key-value-stores/DHMHtotPcN9CAKXYj/records/pal-open-graph-product-price-20261021.html"
  ],
  "monitorId": "pal-reference-gap-demo",
  "minPriceChangePercent": 5,
  "referencePrices": {
    "https://api.apify.com/v2/key-value-stores/DHMHtotPcN9CAKXYj/records/pal-open-graph-product-price-20261021.html": {
      "price": 45,
      "currency": "USD"
    }
  }
}

The first output includes a referenceGap of -5.10 USD, referenceGapPercent of about -11.33, and referenceComparison: "competitor_below_reference", as long as the published demo page remains unchanged. This is a mathematical comparison of published amounts, not an instruction to lower your prices. Taxes, shipping, promotions, marketplace fees, location and currency exchange can alter real customer totals.

• If the competitor currency does not match, the comparison is skipped rather than converting or reporting a misleading gap.
• For pages with multiple Product/Offer rows, the URL-level reference is not applied; the comparison explicitly reports not_available_multiple_offers.
• Input URLs must match the exact source URL keys in referencePrices. Entries for unrelated URLs or invalid prices are rejected before processing begins.
• This comparison is optional. It does not change legacy monitoring behavior, save the reference in shared baseline data, trigger automatic alerts or add a second paid event. The existing product-check price applies to any successfully observed priced product, including a first-run comparison.

Quick start: two runs show the difference

Paste this input into Apify. It uses a verified, synthetic product-price fixture (not an actual retailer), so the first check can establish a baseline with no private data:

{
  "urls": ["https://api.apify.com/v2/key-value-stores/DHMHtotPcN9CAKXYj/records/pal-open-graph-product-price-20261021.html"],
  "monitorId": "sample-competitor-products",
  "minPriceChangePercent": 5,
  "emitUnchanged": true
}

1. Press Start. The first successful price check records a baseline and usually returns eventType: "first_seen".
2. Press Start again using the same monitorId. The Actor compares newly published page data with the last stored snapshot.
3. Open the Dataset tab. Review priceDeltaPercent, eventType and alertSignal. Export the rows as JSON/CSV.
4. For unattended monitoring, configure an Apify Schedule to rerun this Actor daily or weekly using the same input. Configure an Apify webhook or your own integration separately if you need notifications.

Note: The sample page may not change between runs. Seeing unchanged on the second run is normal, and shows the comparison is working.

Example output for a genuine change

Illustrative event, not a claim about the sample website:

{
  "name": "Example product",
  "previousPrice": 100,
  "price": 90,
  "priceDelta": -10,
  "priceDeltaPercent": -10,
  "eventType": "price_down",
  "changed": true,
  "alertSignal": true,
  "alertKind": "price_decrease"
}

An alert signal is data for automation, not an email or push notification. No outbound notification is sent by default.

When price and availability change together

An event with eventType: "price_and_stock_changed" reports both types of movement. When the price movement meets your threshold, alertKind keeps the price alert and additionalAlertKinds / stockAlertKind also capture the availability change. A stock-status alert can still fire for below-threshold price changes.

A product without a usable published price is not charged for a product-check event, but its published metadata is still saved for future comparisons. eventType: "price_visibility_changed" identifies a price appearing or disappearing later. These are static JSON-LD observations, not verified checkout stock.

Matching products reliably between runs

The monitoring baseline now uses stable published product and offer identifiers (such as SKU, product URL, offer URL and seller) rather than the order products appear in JSON-LD. A changed ordering alone should not be interpreted as a new product when these identifiers are sufficient.

When multiple offers are indistinguishable because their identifiers are missing or identical, identityAmbiguous: true appears in the result. Those comparisons may still depend on offer ordering, so treat their changes as leads for manual verification. Previously saved position-based baselines are reused only where a unique SKU/name match permits a safe migration; some products may establish a fresh baseline once after this update.

The Dataset overview includes alertSignal, alertKind, stockAlertKind, referenceGapPercent, referenceComparison and identityAmbiguous so potential pricing actions and uncertainty are easier to review.

Choose the right options

• urls: one to 50 public product URLs with static schema.org Product JSON-LD or explicitly product-typed Open Graph pricing metadata.
• monitorId: 3–40 ASCII letters, digits, hyphens or underscores; reuse it to compare the same group on later runs. Use a distinct ID for unrelated projects, and avoid personal information in it.
• minPriceChangePercent: the minimum percentage move worth flagging; default 5.
• referencePrices: optional JSON map of exact source URL to { "price": 45, "currency": "USD" }; compares only a single observed offer with the same currency. Results include referenceGapPercent and referenceComparison.
• emitUnchanged: set false to omit unchanged dataset rows. Successful unchanged checks can still be billed.
• resetBaseline: set to true only when you intentionally want to discard the previous comparison baseline.

Pricing: what does competitor price monitoring cost?

PAL uses Apify pay-per-event pricing. At the publicly verified standard rates on October 22, 2026, a run-start event costs USD 0.00005 and a successful priced product-check event costs USD 0.0035. Apify confirmed live plan-based product-event discounts on October 23, 2026: Bronze 25% off (USD 0.002625), Silver 40% off (USD 0.0021), and Gold/Platinum/Diamond 50% off (USD 0.00175) compared with the standard product-check event price. The USD 0.00005 run-start event price remains unchanged. Eligibility depends on the buyer's Apify plan; this is not a discount for Free-plan users. Pricing can change, so the Actor's live Pricing tab is authoritative.

For a single run that reads one successfully priced offer per URL:

Priced offers successfully checked	Example event-fee calculation	Estimated event fees
1	$0.00005 start + (1 × $0.0035)	$0.00355
5	$0.00005 start + (5 × $0.0035)	$0.01755
50	$0.00005 start + (50 × $0.0035)	$0.17505

These are illustrative event fees, not guarantees of final invoices. A page may expose multiple priced Product JSON-LD offers (up to 20 per URL). Apify platform charges, subscription plans, changed rates, partial extraction, retry behavior and other platform conditions may affect actual costs. Repeat monitoring incurs a new run-start event and a product-check for every newly observed priced product, even when its price is unchanged.

Errors and rows without a usable published price do not trigger a product-check event; the run-start charge may still apply. The optional first-run referencePrices comparison does not add another product-check event.

To estimate fees for another scenario, multiply successful priced product checks by the live product-check event rate and add the current run-start charge. Review this Actor's current Apify Pricing tab.

Try an actual public Example task

Open the preconfigured competitor price-and-stock monitoring Example to inspect its settings before starting. For a first-run comparison of a fictional competitor price (USD 39.90) against a reference price (USD 45), use the synthetic Open Graph input in the Compare competitor prices with your own on the first run section above.

Previewing documentation is free. Starting an Apify run can incur charges. No real retailer sales figures or checkout-verification claims are implied by the samples.

Important limits

This Actor reads only public static HTML with Product JSON-LD or strictly validated product-type Open Graph price tags. It cannot log in to stores, render JavaScript-generated data, scrape protected private pages, verify live checkout stock, normalize different currencies or guarantee that a site updates its metadata promptly. Output relies on what the source page actually publishes.

Fetching is bounded to a 2 MB HTML response and a 12-second network timeout per page. Data storage and scheduling follow your Apify plan. Avoid simultaneous runs of the same monitorId to prevent conflicting baselines.

Related PAL tools

• PAL Ecommerce Product Listing QA: batch-check up to 50 product pages for missing price, currency, SKU, images and other metadata.
• PAL Product Price & Stock Snapshot: extract current public product markup into structured data.
• PAL Product Image SEO & JSON-LD QA: review product image structured data, alt attributes and social preview images.

Practical AI Lab (PAL) — exportable ecommerce data and QA workflows.

Frequently asked questions

Why does my first monitoring run show no changes?

The first successful run establishes a baseline. Use the same monitorId in later runs to compare prices and published availability labels over time.

Does alertSignal send an email automatically?

No. It is a field in the output. Connect an Apify webhook or another downstream workflow if you need a real notification.

How can I safely make this recurring?

For a first price-monitoring trial, follow the Quick start section above using the prefilled synthetic product sample. Start with one check, inspect the per-run costs, and schedule repeat monitoring only if it is useful.