Use PriceFetch to poll competitor product pages on a schedule, store price history, and trigger repricing or alerts when competitors change prices.
If you sell products that competitors also carry, you're flying blind without price monitoring. Customers comparison-shop. If your competitor drops a price by 10% and you don't notice for a week, that's a week of lost sales or eroded margins.
Price monitoring gives you three things: awareness of competitor pricing moves, data for your own pricing decisions, and the ability to react quickly — ideally automatically. Most enterprise solutions charge $500+/month for this. With a price API and a cron job, you can build it for the cost of API credits.
The core loop is simple: maintain a list of competitor product URLs, fetch prices on a schedule, compare against your prices, and take action when the delta exceeds your threshold.
A production price monitoring system has four components:
1. **Product catalog** — a database table mapping your SKUs to competitor URLs. Each row has your product ID, the competitor URL, and the last known price.
2. **Scheduler** — a cron job or task queue that triggers price checks. For most use cases, checking every 4-6 hours is sufficient. High-volume sellers might check hourly for key products.
3. **Price fetcher** — the service that calls PriceFetch and stores results. This is where retry logic and error handling live.
4. **Action layer** — what happens when a price changes. This could be a Slack notification, an automatic repricing API call to your storefront, or a row in a dashboard.
Keep the fetcher and action layer decoupled. You want to store every price data point regardless of whether it triggers an action — the historical data is valuable for trend analysis.
import requests
import time
from datetime import datetime
API_KEY = "pf_live_abc123"
BASE_URL = "https://api.pricefetch.dev/v1/price"
def check_prices(product_urls: list[dict]) -> list[dict]:
"""Check prices for a list of competitor products."""
results = []
for product in product_urls:
try:
resp = requests.get(
BASE_URL,
params={"url": product["url"]},
headers={"X-API-Key": API_KEY},
timeout=30,
)
data = resp.json()
if data["success"]:
results.append({
"sku": product["sku"],
"competitor_url": product["url"],
"price": data["data"]["price"],
"currency": data["data"]["currency"],
"in_stock": data["data"]["in_stock"],
"checked_at": datetime.utcnow().isoformat(),
})
time.sleep(0.5) # Respect rate limits
except Exception as e:
print(f"Failed to check {product['url']}: {e}")
return resultsRaw price snapshots become useful when you can query trends. Store every check result with a timestamp. A simple schema works:
- `sku` — your internal product identifier - `competitor_url` — the URL you checked - `price` — the price returned - `currency` — currency code - `in_stock` — boolean - `checked_at` — timestamp
With this data, you can answer questions like: "What was the average price of product X on Amazon over the last 30 days?" or "How often does competitor Y discount this product?" These insights inform your pricing strategy beyond simple reactive repricing.
For most e-commerce businesses, PostgreSQL (or Supabase) handles this volume easily. A catalog of 1,000 products checked every 6 hours generates about 120,000 rows per month — trivial for any modern database.
There are three common strategies for acting on price data:
**Threshold alerts** — notify your team when a competitor's price drops below yours by more than X%. Good for businesses that want human decision-making in the loop. Send alerts to Slack, email, or your internal dashboard.
**Rule-based repricing** — automatically adjust your price based on rules. Example: "Always be $1 cheaper than Amazon, but never go below $15." This works well for commodity products where you compete primarily on price.
**Dynamic repricing** — use price history plus demand signals to set optimal prices. This is more complex and typically involves a separate pricing engine. The price API feeds data in, but the pricing logic is its own system.
Start with threshold alerts. Once you trust the data pipeline, layer on automated repricing for your highest-volume products. Keep manual review for high-margin items where you don't want to race to the bottom.
Price monitoring at scale means thousands of API calls per day. Here's how to keep costs reasonable:
**Tiered check frequency** — check your top 100 products every 2 hours, the next 500 every 6 hours, and the long tail once daily. Not every product needs real-time monitoring.
**Skip out-of-stock products** — if a product was out of stock on the last check, reduce the check frequency. It's unlikely to have a meaningful price change while unavailable.
**Batch by retailer** — group your checks by retailer and stagger them. This avoids hitting rate limits and spreads your API usage evenly throughout the day.
**Cache and diff** — only store and alert on actual price changes. If the price hasn't moved since the last check, log it but don't trigger actions. This reduces noise and saves processing time downstream.
Sign up in 30 seconds. No credit card required. One credit per successful API call.