Track competitor pricing pages with a weekly snapshot

This pricing page snapshot reads a few pricing pages and builds one table of plans and prices, copied from the page text. Save it, run it again next week and see what changed. A saved prompt does the job with no code in any MCP client, and a small Python CLI does the same from the terminal. This page shows a stored sample; there is no hosted demo.

The problem

Pricing pages change without notice. Plans get renamed, prices move and billing terms shift from monthly to yearly. Checking each page by hand every week is slow, and notes from memory are not reliable. You need the plans and prices as the page states them, with a date, and a list of what changed since the last check.

What the app does

• Reads each pricing page once with the Desearch extract tool, and once more if the text comes back empty.
• Finds each price line and the plan name right above it, in page order.
• Notes the billing line under the price when the page shows one, such as "Billed yearly".
• Marks pages with no prices in the text as "No prices in page text" instead of guessing.
• With --compare, lists added and removed plans and price changes against an earlier snapshot.

How it works

1. List the pages. Pass the pricing URLs on the command line, or paste them into the saved prompt.
2. Read the text. Each page is read through the hosted Desearch MCP server (https://mcp.desearch.ai/mcp) with the extract tool, format: text and js: false.
3. Parse plans. A line that starts with a currency amount or "Custom" is a price. The short line right above it is the plan name. A price with no name above it is marked "(name not in page text)".
4. Save and compare. --save writes the snapshot as JSON. Next week, --compare reads the earlier file and prints the differences.

Some pricing pages build their prices with JavaScript and show no prices in the page text. The CLI reports those pages instead of guessing, so check them on the live page.

The code

This verbatim excerpt from pricing_snapshot.py turns page text into a list of plans:

def parse_plans(text):
    """Find 'Plan name' followed by a price line, in page order. First match per plan only."""
    lines = [l.strip() for l in (text or "").splitlines() if l.strip()]
    plans, seen = [], set()
    for i, line in enumerate(lines):
        if not is_price_line(line):
            continue
        name = NO_NAME
        prev = lines[i - 1] if i else ""
        if prev and len(prev) <= 30 and not is_price_line(prev) and not prev.endswith((".", ":", "+")):
            name = prev
        if name in seen:
            continue
        seen.add(name)
        period = ""
        for nxt in lines[i + 1:i + 3]:
            if re.search(r"billed (yearly|annually|monthly)|annual billing", nxt, re.I):
                period = nxt
                break
        plans.append({"plan": name, "price": line, "billing": period or "not shown"})
        if name == NO_NAME:
            seen.discard(name)
    return plans

View the code

Endpoints

• MCP tool extract (format: text, js: false)

Example output

From samples/live-run-2026-10-16.md in the source folder, a live run on one public pricing page:

Page | Plan | Price as written | Billing | Snapshot date
https://linear.app/pricing | Free | $0 | not shown | 2026-10-16
https://linear.app/pricing | Basic | $10 per user/month | Billed yearly | 2026-10-16
https://linear.app/pricing | Business | $16 per user/month | Billed yearly | 2026-10-16
https://linear.app/pricing | Enterprise | Custom | Annual billing only | 2026-10-16

Prices are copied as written on the page on that date. They are not a statement about current prices.

Run it yourself

Get the Python examples and open the pricing page snapshot folder. Create an API key in the console and save it in ~/.desearch-api-key, a file only you can read, or pass --key-file PATH.

git clone https://github.com/Desearch-ai/desearch-py-examples
cd desearch-py-examples/pricing-page-snapshot
python -m venv .venv && . .venv/bin/activate
pip install -r requirements.txt

These commands are copied from the source README. The second run compares with the first:

python pricing_snapshot.py https://linear.app/pricing https://www.figma.com/pricing/ --save snapshot-1.json
# next week
python pricing_snapshot.py https://linear.app/pricing https://www.figma.com/pricing/ --compare snapshot-1.json --save snapshot-2.json

For the no-code version, paste a prompt from saved-prompt.md into your MCP client with the Desearch MCP server connected. Prompt 1 builds the table with key limits and free tier; prompt 2 compares it with your last table.

What it costs

On 2026-10-16, one page read cost $0.0005, read from the X-Desearch-Cost-Usd header of the same plain text extraction. The run made 2 calls for about $0.001 in total and returned 2,021 characters of page text in 2.9 seconds. A weekly check of five pages is a handful of calls. These are dated measurements, not current price quotes. Check pricing before a larger run.

Ideas to extend it

• Schedule the CLI weekly and keep each snapshot file with its date.
• Post the --compare output to a team channel when a plan or price changes.
• Add the key limits and free tier columns from saved prompt 1 to the CLI output.
• Flag pages that show no prices in the text for a manual check.