Compare competitor prices and stock with the fields your repricing review needs

{
    "product_url": "https://example.com/products/linen-shirt",
    "variant": "M / blue",
    "price": 29,
    "currency": "USD",
    "availability": "in_stock",
    "observed_at": "2026-09-17T10:00:00Z",
    "region": "US",
    "match_status": "accepted"
}

When this fits

This pilot fits a team that monitors competitor product pages and needs a reviewable record for price, stock and variant matching. The proposed fields are product_url, variant, price, currency, availability, observed_at, region and match_status. They keep the facts needed for a later repricing review in one row.

This is a proposed pilot, not an already available managed API or a promise of coverage, dataset, benchmark, SLA or launch date. ProxyLane can review the source list and rules, then confirm feasibility, scope, price and acceptance criteria. Use the Request access button on this page to start.

What the record should mean

The variant and unit or pack are part of the comparison. A matching URL with the wrong pack size can create a false price signal. Unknown stock is not out of stock, and a failed fetch is not a price drop.

Synthetic example and pilot shape

Download the synthetic JSON sample or CSV sample. It contains illustrative records only. The accepted row has enough information for a review; the other rows show why a missing or uncertain observation should stay visible instead of becoming a confident repricing instruction.

A concrete pilot can start with the source list, requested fields, regions, refresh interval, output format, expected volume and acceptance rules. A proposed acceptance check is: every accepted record has the agreed URL, variant, numeric price, currency, availability, observation time, region and match_status=accepted; records with missing or uncertain values are marked for review or unknown; no failed fetch is labeled a price drop. The output is accepted only after a human compares it with those rules.

The buyer economics can be stated without inventing a result: reviewable repricing value = avoidable margin loss or missed margin identified by an accepted observation − pilot cost. The terms, baseline and measurement window belong in the agreed worksheet. The sample proves the shape of a check, not the value of a live result.

Try the sample locally

Save the downloaded file as sample.json, then run this standard-library check from the same directory:

import json
import math
from datetime import datetime, timezone
from pathlib import Path
from urllib.parse import urlparse

required = {
    "product_url", "variant", "price", "currency", "availability",
    "observed_at", "region", "match_status",
}
allowed_hosts = {"example.com", "example.org"}
allowed_statuses = {"accepted", "review", "unknown"}

records = json.loads(Path("sample.json").read_text())
if records.get("sample_type") != "synthetic":
    raise ValueError("This check expects sample_type=synthetic")

for index, record in enumerate(records.get("records", []), start=1):
    if not isinstance(record, dict):
        print(f"record {index}: review, record is not an object")
        continue
    missing = sorted(required - record.keys())
    if missing:
        print(f"record {index}: review, missing {', '.join(missing)}")
        continue
    status = record["match_status"]
    if status not in allowed_statuses:
        print(f"record {index}: review, invalid match_status")
        continue
    if record.get("fetch_status") == "failed":
        print(f"record {index}: review, failed fetch")
        continue
    url = urlparse(record["product_url"])
    text_fields = (record["variant"], record["currency"], record["region"])
    valid_url = url.scheme == "https" and url.hostname in allowed_hosts
    valid_text = all(isinstance(value, str) and value.strip() for value in text_fields)
    try:
        observed_at = datetime.fromisoformat(record["observed_at"].replace("Z", "+00:00"))
        valid_time = observed_at.tzinfo is not None and observed_at.utcoffset() is not None
    except (AttributeError, TypeError, ValueError):
        valid_time = False
    price = record["price"]
    valid_price = isinstance(price, (int, float)) and not isinstance(price, bool) and math.isfinite(price) and price >= 0
    valid_stock = record["availability"] in {"in_stock", "out_of_stock"}
    accepted = status == "accepted" and all((valid_url, valid_text, valid_time, valid_price, valid_stock))
    print(f"record {index}: {'accepted' if accepted else 'review'}")

The check reports uncertainty instead of filling missing values. It validates schema shape and timestamps; it cannot prove that a fetched price matches the product or variant, which requires the agreed review process. It is a local example and makes no ProxyLane API call.

Questions buyers usually ask

Can this feed automatic repricing? Start with human review. Automation depends on the agreed match and acceptance rules, and no automatic repricing is promised here.

What happens when a page fails? Keep the observation as review or unknown. Do not infer a price change or out-of-stock state from a failed fetch.

Can you confirm coverage or delivery timing now? The team confirms those points after reviewing the source list and requirements.

How do I start? Select Request access on this page. The draft includes the vertical, source list, fields, geography, refresh interval, output format, expected volume and acceptance rules, and is not sent automatically.

Request access when you are ready to define those inputs.