Your competitor changes their pricing page at 2 AM. By 9 AM, their "Pro" plan is $10 cheaper, their headline claims a new AI feature you don't have, and a prospect who was about to sign up is now comparing quotes. If you're relying on manual checks, you'll find out weeks later — or never.
Competitive intelligence shouldn't be a manual chore. It should be an automated pipeline that watches every pricing page, product page, and changelog in your market, and pings you the moment something moves. This guide shows you how to build exactly that with DiffCheck, the web-page diff API from FetchAPI, plus Markdownify for extracting structured pricing data from pages that changed.
Before diving into the API, it's worth understanding why "just scrape the page every hour and compare" doesn't work:
sha256(page)) tells you that something changed, never what changed.The solution is a diff service that normalizes the page first, then computes a structured diff you can actually act on. That's the job DiffCheck was built for.
DiffCheck is the web-page diff endpoint in the FetchAPI suite. You give it a URL, and it returns whether the page changed and a structured diff of what's different:
curl -s "https://fetchapi.tech/v1/diffcheck?url=https://competitor.example.com/pricing"
Response:
{
"changed": true,
"diff": [
{
"type": "change",
"old": "$49/month",
"new": "$39/month"
},
{
"type": "add",
"text": "Includes AI-powered insights"
}
]
}
Instead of a wall of HTML, you get a clean list of semantic changes: what was removed, what was added, and what changed from one value to another. Exactly the signal a price-monitoring pipeline needs.
Note: DiffCheck is currently in the FetchAPI roadmap (the endpoint is
GET /v1/diffcheck?url=...). The architecture below is exactly what it's designed for — and the pattern works today with the live Markdownify endpoint for the extraction half of the pipeline.
The first step in any monitoring pipeline is establishing what the page looks like today. For that you want clean, normalized content — not raw HTML. FetchAPI's Markdownify endpoint converts any URL to markdown, stripping ads, nav, popups, and cookie banners:
curl -s "https://fetchapi.tech/v1/markdownify?url=https://competitor.example.com/pricing"
Response:
{
"content": "# Pricing\n\n## Pro\n\n$49/month — billed annually\n\n- Unlimited projects\n- AI-powered insights\n- Priority support\n",
"title": "Pricing — Competitor Inc.",
"url": "https://competitor.example.com/pricing",
"word_count": 312,
"char_count": 1984
}
Store this first snapshot. It's your baseline — the version of truth that every future check will be compared against.
Price monitoring is a polling loop: check the page, compare against the last known state, and act if something moved. A sensible cadence is every 4–6 hours for pricing pages (prices rarely change more often, and you avoid hammering the target's server).
A minimal poller in bash looks like this:
#!/bin/bash
URL="https://competitor.example.com/pricing"
LAST="/var/lib/pricewatch/last.json"
# Fetch the current state
curl -s "https://fetchapi.tech/v1/diffcheck?url=$URL" > /tmp/current.json
# First run: store baseline, exit
if [ ! -f "$LAST" ]; then
cp /tmp/current.json "$LAST"
echo "Baseline captured."
exit 0
fi
# Check if anything changed
CHANGED=$(jq -r '.changed' /tmp/current.json)
if [ "$CHANGED" = "true" ]; then
jq '.diff' /tmp/current.json
# ... alert (see Step 4)
cp /tmp/current.json "$LAST"
fi
The key design decision: store the last response, not just a hash. Because DiffCheck returns the actual diff, the next poll can compare against the latest known state — so even if you miss a change while your monitor is down, the next run still catches up. (This mirrors how the API works under the hood: it maintains per-URL history so you can diff against any previous snapshot.)
A diff tells you what changed, but for pricing intelligence you usually want the number: did the price go up or down, and by how much? Pair the diff output with a small parser to extract currency amounts:
import json, re
diff = [
{"type": "change", "old": "$49/month", "new": "$39/month"},
{"type": "add", "text": "Includes AI-powered insights"}
]
price_re = re.compile(r"\$?(\d+(?:[.,]\d+)?)")
for item in diff:
if item["type"] == "change":
old_m = price_re.search(item["old"])
new_m = price_re.search(item["new"])
if old_m and new_m:
old_price = float(old_m.group(1).replace(",", ""))
new_price = float(new_m.group(1).replace(",", ""))
delta = new_price - old_price
print(f"PRICE CHANGE: {item['old']} -> {item['new']} ({delta:+.2f})")
elif item["type"] == "add":
print(f"NEW CONTENT: {item['text']}")
Output:
PRICE CHANGE: $49/month -> $39/month (-10.00)
NEW CONTENT: Includes AI-powered insights
That's the actionable signal: your competitor dropped their Pro price by $10. Feed that straight into your pricing review, your sales team's battle cards, or a database of historical price moves.
A monitoring pipeline that doesn't alert anyone is just a very slow archive. Route the diff to wherever your team already works. The cheapest reliable option is a Slack or Discord webhook:
curl -s -X POST "https://hooks.slack.com/services/T000000/B000000/XXXXXXXXXXXXXXXXXXXXXXXX" \
-H "Content-Type: application/json" \
-d '{
"text": "🚨 Competitor Inc. changed pricing!",
"blocks": [
{
"type": "section",
"text": {
"type": "mrkdwn",
"text": "*Competitor Inc. /pricing*\n• Pro plan: ~~$49/month~~ → *$39/month*\n• Added: \"Includes AI-powered insights\"\n\n<https://competitor.example.com/pricing|View page>"
}
}
]
}'
If you're building AI agents, this is where it gets fun: instead of a human Slack channel, route the diff JSON to your LLM pipeline. An agent can summarize the change, compare it against your own pricing, and draft a response strategy — all without human intervention. (FetchAPI's MCP server makes wiring DiffCheck and Markdownify into agent frameworks like Claude Desktop and Hermes a one-line config.)
Once the pipeline is running for prices, extend the same pattern to everything that matters:
The pattern is identical for every target: diff, parse, alert. One pipeline, N competitors, zero manual checking.
A few hard-won lessons for running this reliably at scale:
price|plan|/month|annual) so only meaningful changes page your team./v1/markdownify and feed it to your LLM for a structured summary — diff for signal, markdown for context.Here's the whole thing in one file — a cron-friendly script that checks a competitor page, diffs it, and alerts Slack on change:
#!/bin/bash
URL="${1:?usage: pricewatch.sh <url>}"
STATE="/tmp/pricewatch_$(echo "$URL" | md5sum | cut -d' ' -f1).json"
curl -s "https://fetchapi.tech/v1/diffcheck?url=$URL" > /tmp/pw_now.json
if [ ! -f "$STATE" ]; then
cp /tmp/pw_now.json "$STATE"
echo "Baseline saved."
exit 0
fi
if [ "$(jq -r '.changed' /tmp/pw_now.json)" = "true" ]; then
DIFF=$(jq -c '.diff' /tmp/pw_now.json)
echo "Change detected on $URL: $DIFF"
# Add your Slack/Teams/webhook call here, then:
cp /tmp/pw_now.json "$STATE"
fi
Add 0 */6 * * * /usr/local/bin/pricewatch.sh https://competitor.example.com/pricing to your crontab and you're live.
Competitive pricing intelligence is one of the highest-ROI automations a SaaS company can build, and with FetchAPI it's a single cron job plus two API calls. While DiffCheck completes its rollout, the Markdownify endpoint is live today — you can build the full baseline-and-extract pipeline right now and plug DiffCheck in the moment it ships.
Watch the FetchAPI blog for the DiffCheck launch announcement, and check the docs for the full API reference. Your competitors are changing their prices whether you're watching or not — you might as well be the first to know.