Anatomy of a Price Monitor: From URL to Alert in 5 Minutes

From URL to Alert in Five Minutes. Here Is Exactly How.

Most "build a price monitor" tutorials skip the hardest part: actually shipping something end-to-end without a weekend of yak shaving. This article walks through a real price monitor, from the first URL to the first alert in your inbox, in roughly five minutes of actual work.

The point is not to impress you with a one-line setup. The point is to show you what each piece does and where the trade-offs sit, so you can adapt this pattern to your own targets.

We use the platform for the scraping and scheduling layer and a webhook-to-email service for the alert. You could swap either piece; the architecture is what matters. You can set up your first price monitor on Trawl in minutes. The platform handles scraping, scheduling, and change detection.

What You Will Learn

• The architecture of a price monitor
• Step 1: Pick the URL and inspect the page
• Step 2: Define the extraction schema
• Step 3: Create the scrap
• Step 4: Schedule the scrap
• Step 5: Wire the alert
• What happens when the price changes
• Extensions you will want on day two
• Key takeaways
• FAQ

The Architecture of a Price Monitor

A price monitor has five layers. For a deeper dive into each layer, see our price monitoring playbook.

1. Target. The page you want to watch.
2. Schema. The shape of the data you extract. Usually: price, currency, title, URL, timestamp.
3. Scheduler. A cron or similar that runs the scrape periodically.
4. Diff. Logic that detects when the new price differs from the last known price.
5. Alert. Something that turns a diff into a notification you actually see.

You can build each layer yourself, but for a simple monitor it is not worth it. The interesting part is the business logic (what counts as a meaningful change) not the plumbing.

Step 1: Pick the URL and Inspect the Page

Start with a specific product page, not a search result. Search pages change ordering and pagination, which makes diffing noisy. A canonical product URL is stable.

Open the page in your browser. Right-click the price. Use Inspect Element. Note the CSS selector that identifies the price. Also note the currency (is it a symbol, a three-letter code, implicit from the site's locale?). This takes one minute.

Check whether the price is rendered server-side (visible in View Source) or client-side (only visible in Inspect Element). Server-side prices work with simple HTTP fetches. Client-side prices need JavaScript rendering. The platform handles both, but the choice affects cost per scrape, so pick the cheapest path when possible.

Step 2: Define the Extraction Schema

Your schema is the shape of data you care about. Keep it minimal at first. A typical price monitor schema looks like this:

1. title: the product name as displayed on the page
2. price: the current sale price as a number
3. currency: the price currency, such as USD or EUR
4. availability: whether the item shows as in stock or out of stock
5. url: the URL of the page being monitored

Minimum viable scrape. Do not add stock, reviews, seller names, or delivery estimates yet. You can add them in iteration two. Start small, ship, then extend based on what you actually need. For the full competitive monitoring strategy, see our guide on monitoring competitor prices automatically.

Step 3: Create the Scrap

On the platform, a scrap is defined by a URL, a schema, and an extraction method. You can use AI extraction (give the schema in natural language), selector-based extraction (paste the CSS selectors you noted in step 1), or hybrid extraction (AI with selectors as fallback).

For this price monitor, AI extraction is usually sufficient and fastest to set up. Paste the URL, paste the schema, add a one-line prompt like "Extract current sale price, title, and availability. Ignore strikethrough prices." Hit save.

The first run happens immediately. Check the output. If it looks right, you are ready for scheduling. If the price is wrong (often because there are two prices on the page, or a "from" prefix confuses the extractor), tighten the prompt or switch to selector-based extraction.

Your first price monitor is one scrap away. Get started free and have data flowing in minutes.

Step 4: Schedule the Scrap

Set the scrap to run on a schedule. Price monitors rarely need subminute precision. Every fifteen minutes is usually overkill. Every hour covers most use cases. Every six hours is fine for long-tail monitoring. For inspiration on what to monitor, browse our 10 price monitoring workflows that actually ship.

A common mistake is to set too frequent a schedule at first. You end up paying for scrapes that never produce new data. Start with one hour. Reduce to fifteen minutes only if you have observed that prices genuinely change more often than hourly on your target.

Also: respect the target. Do not hit a small merchant site every minute. Both for their infrastructure and for the ethics of it. Trawl handles rate limiting and proxy rotation automatically, so you can focus on the data rather than the plumbing.

Step 5: Wire the Alert

Trawl fires a webhook whenever a scrap produces a new result. To turn that into an alert, point the webhook at a service that emails you on change.

The simplest setup uses a lightweight integration platform (n8n, Zapier, Make) with two nodes: a webhook trigger that receives the scrap payload, and a branching node that compares the new price to the previous one. If the new price is lower by more than some threshold, fire an email or a Slack message.

Another valid approach is to write a small handler function that receives the webhook and does the diff plus alert itself. Either works. Pick whichever has less cognitive overhead for you.

What Happens When the Price Changes

Ten minutes after you finish setup, your scrap runs, reads the page, extracts the price, and sends the payload to your webhook. Nothing changes the first time because there is no previous price to compare.

Run two, one hour later, compares. Still no change. Silence.

Run seven, six hours later, the merchant drops the price by twelve percent. The webhook fires. Your handler checks the threshold, sees the delta, and sends you an email. You open your laptop and decide whether to reprice, restock, or write a competitive note.

This is the moment the monitor pays for itself. A price change you would have missed for days, caught within six hours with no ongoing effort.

Extensions You Will Want on Day Two

Once your first monitor is live, you will want to extend it. The usual order is:

• Multiple URLs. One monitor is a hobby. Ten monitors across ten competitors is a strategy.
• Thresholds. Only alert on changes above a certain percentage, to cut noise on normal price churn.
• Rate of change. A single ten percent drop is different from three successive drops over a day. Track trends, not just spot values.
• Availability. Alert when items go out of stock or come back in stock, not just on price.
• Dashboard. A weekly view of price movements across your catalog, to spot patterns (this competitor drops prices every Tuesday).

None of these are premature at day two. By the time you have ten targets under monitoring, you will want at least thresholds and availability. The rest follows naturally.

Key Takeaways

• A real price monitor has five parts: target, schema, scheduler, diff, alert.
• Start with one URL, a minimal schema, and an hourly schedule. Extend later.
• Pick canonical product pages, not search pages, for stable diffs.
• Webhooks plus a thin integration layer is the fastest path from scrape to alert.
• The value of price monitoring comes from the cumulative small wins, not the dramatic one-off catches.

Start small: one URL, one schema, one hourly schedule. The data pipeline pattern scales naturally from there.

Frequently Asked Questions

Written by Leo Harmon, assisted by AI | May 2026

Disclaimer: Trawl provides scraping infrastructure. Users are responsible for ensuring their use complies with applicable laws and website terms of service. This article is for educational purposes only.