AI competitor price monitor with daily email alerts

Competitor price monitoring has long since ceased to be a discipline only for large e-shops with their own data team. Today, it is possible to build a practical system even with commonly available cloud services, a spreadsheet, automation, and one AI model that will not just mechanically report changes, but also evaluate them right away. The result is very useful: every day you receive a brief and understandable email summary of where competitors lowered prices, where they raised them, which products fell below your price, and which changes are already worth a merchant’s intervention.

This article is a practical guide to a working MVP of the project. The goal is not to build an enterprise platform with hundreds of integrations, but a solution you will actually be able to launch. We will use real services, specific fields, setup examples, and simple mini snippets. The process is intentionally smooth: first we prepare the data foundation, then we obtain prices, compare them, evaluate changes using AI, and finally send everything in a daily email alert.

Introduction

A typical problem in practice looks like this: you sell dozens or hundreds of items, several competitors change prices irregularly, and manual checking is both slow and unreliable. It is not enough just to know that “something changed.” You need to answer specific questions:

Which products had a price change compared to yesterday?
Who is the cheapest now?
By what percentage are we above or below the competition?
Which changes are important and which can be ignored?
What should the sales team do about it today?

That last point is exactly why it makes sense to involve AI in the project. Not because of the price collection itself, which is fundamentally a data task, but because of summarizing, prioritizing, and explaining changes in a human-readable form. In this project, AI functions as an analytical layer above already prepared data.

Project goal

Try NordVPN

The goal is to create an MVP that performs these actions once a day:

Loads the list of monitored products and their competitor URLs.
Obtains the current price from selected competitor pages.
Compares the current state with the previous day.
Matches prices with your internal reference price.
Uses AI to create a brief evaluation of changes and recommended priorities.
Sends a daily email with a summary of the results.

In this article, we build the working MVP on these principles:

inputs will be stored in Google Sheets,
automation will be handled by Make,
AI evaluation will be handled by the OpenAI API,
the email will be sent via Gmail in Make,
to obtain prices, we will use two realistic options: a publicly available product feed or an HTML page via the HTTP module.

It is important to add a limitation: not every e-shop allows easy or legally trouble-free downloading of prices from HTML. If a store provides a public XML feed or API, that is usually a more stable route. If not, you need to verify the terms of the specific website and expect the solution to be more fragile.

Prerequisites

Try Make

Before you start, prepare the following:

a Google account with access to Google Sheets and Gmail,
a Make account, ideally with the ability to schedule scenario runs,
an OpenAI API key,
a list of at least 10 products you want to monitor,
for each product, an internal code or SKU and at least one competitor URL or feed link,
a basic decision on what you consider an important change, for example a price drop of more than 3% or a difference from your price greater than CZK 50.

For the MVP, we will work with three sheets in one Google Sheet:

products – a list of your products and links to competitors,
price_snapshots – daily historical price records,
alert_log – history of sent alerts and run status.

Once you are clear on the data and access, we can start building. First, we will prepare the structure without which the automation will quickly fall apart.

Implementation steps

Try Hostinger

Step 1: Design the data model in Google Sheets

What and why: Before you start downloading any data, you need a stable structure. Without it, it will be difficult to match products, calculate changes, and generate alerts. For an MVP, a spreadsheet is ideal: it is readable, easy to edit, and Make works with it without complicated setup.

Exactly how: In Google Sheets, create a new file named for example Competitor price monitoring. Create the sheets products, price_snapshots, and alert_log.

Insert these columns into the products sheet:

product_id | sku | product_name | own_price | competitor_name | competitor_url | source_type | price_selector | currency | active

Example row:

1001 | NB-ACER-15 | Acer Aspire 15 | 12990 | Alza | https://www.alza.cz/... | html | .price-box__primary-price__value | CZK | TRUE

Insert into the price_snapshots sheet:

snapshot_date | product_id | competitor_name | fetched_price | currency | availability | source_url | fetch_status | raw_value

Insert into the alert_log sheet:

alert_date | total_products | changed_prices | critical_items | email_subject | send_status | scenario_run_id

Specific input: The price_selector column with the value .price-box__primary-price__value.

Specific output: A prepared Sheet with three sheets and at least 10 active rows in products.

Success metric: 100% of monitored products have product_id, own_price, competitor_url, source_type, and active filled in.

This creates a solid foundation. In the next step, we will connect automation to this structure so the data does not have to be processed manually.

Step 2: Create a daily scheduled scenario in Make

What and why: You need the system to run automatically every day without manual intervention. Make is suitable for an MVP because it supports scheduled runs, working with Google Sheets, HTTP requests, conditions, and email.

Exactly how: After logging into Make, click Create a new scenario. As the first module, choose Tools > Scheduler. Set:

Run scenario: Every day
Time: 07:00
Timezone: Europe/Prague

Then add the Google Sheets > Search Rows module and connect your Sheet. Set:

Spreadsheet: Competitor price monitoring
Sheet: products
Limit: 100
Query: active = TRUE

If the query does not work exactly like this in your specific configuration, use simple row loading and a filter directly in Make. This is one of the limitations of the Google Sheets and Make combination: filtering syntax may differ depending on the module used and the connection type.

Mini process in Make:

Scheduler
Google Sheets – Search Rows
Filter: active = TRUE

Specific input: Schedule setting 07:00 Europe/Prague.

Specific output: A list of active product rows passed to the following modules.

Success metric: The scenario runs 7 days in a row without manual intervention and loads the expected number of active rows.

Once we have the daily run, we can move on to the most sensitive part: obtaining the current price.

Step 3: Obtain the current price from a feed or HTML page

What and why: The purpose of this step is to convert a competitor page or feed into one specific number, namely the current price. For a less advanced reader, it is good to know that we are not solving a full scraping framework here. For an MVP, we just need to reliably get the price into the spreadsheet.

Exactly how: In the products sheet, we have the source_type field. Based on it, we choose the scenario branch in Make.

Option A: XML feed

If the competitor offers a public feed, add the HTTP > Make a request module.

Example settings:

Method: GET
URL: https://www.example-eshop.com/feed/products.xml
Parse response: Yes

Then use a module for working with XML or text and find the price according to a matching identifier, for example EAN or product name. If the feed contains multiple products, you need to know exactly what to match by. If this is not certain, that is a limitation and the feed may not be usable for accurate comparison.

Option B: HTML page

Add the HTTP > Make a request module with the URL from the competitor_url column. Then use the Text parser module or functions over the HTML output. For simpler pages, searching by the CSS selector listed in the price_selector column is sufficient. Make does not have a universal visual extractor for all websites, so for some pages it may be necessary to work with a regular expression or deploy another legal data source.

Example of a simple regular expression for a price in HTML:

(\d{1,3}(?:[ .]\d{3})*(?:,\d{2})?)\s?Kč

Example input:

<div class="price-box__primary-price__value">12 490 Kč</div>

Expected output:

12 490

Then normalize the price, for example replace spaces and the comma:

replace(replace(raw_price; " "; ""); ","; ".")

Specific input: URL https://www.example-eshop.com/notebook-acer-aspire-15 and selector .price-box__primary-price__value.

Specific output: A normalized price value, for example 12490.

Success metric: At least 90% of active products return a readable price without manual correction.

Once we can download the price, it needs to be stored safely. Without history, we would not know what changed compared to yesterday.

Step 4: Save the daily snapshot and calculate the change compared to yesterday

What and why: Individual price fetches are useful only if you store them over time. A snapshot is a daily record thanks to which you can identify both the trend and the specific change. This step is also essential for AI, because the model must receive structured data, not a disorganized stream of HTML.

Exactly how: After obtaining the price, add the Google Sheets > Add a Row module to the price_snapshots sheet.

Field mapping:

snapshot_date = formatDate(now; "YYYY-MM-DD")
product_id = products.product_id
competitor_name = products.competitor_name
fetched_price = normalized_price
currency = products.currency
availability = "unknown"
source_url = products.competitor_url
fetch_status = "ok"
raw_value = raw_price

Then add another Google Sheets > Search Rows module to price_snapshots to find the latest older record of the same product and competitor. Then calculate the change.

Mini formula for percentage change:

((today_price - yesterday_price) / yesterday_price) * 100

Example input:

today_price = 12490
yesterday_price = 12990

Expected output:

-3.85

If yesterday’s price does not exist, mark the status as new_tracking and do not calculate the change. It is better to explicitly admit that on the first day there is nothing to compare against than to create misleading output.

Specific input: Fields snapshot_date and fetched_price.

Specific output: A new row in price_snapshots and a calculated change field, for example -3.85 %.

Success metric: For at least 95% of products, the snapshot is saved without mapping errors, and for products with history, the change is calculated correctly.

Now we know what changed over time. The next step adds business meaning: comparison with your own price.

Step 5: Calculate the difference from your price and determine priority

What and why: A competitor price change alone does not yet tell you whether you have a problem. If a competitor lowered the price by 2% but is still more expensive than you, it may not be important. Therefore, we calculate the difference from the own_price field and introduce simple prioritization.

Exactly how: In Make, add the Tools > Set variable module or a similar calculation step. Use these helper fields:

price_diff_czk = own_price - fetched_price
price_diff_pct = ((own_price - fetched_price) / own_price) * 100

Example:

own_price = 12990
fetched_price = 12490

Expected output:

price_diff_czk = 500
price_diff_pct = 3.85

Then set simple priority rules:

critical – the competitor is cheaper by more than 3% or more than CZK 300,
warning – the competitor is cheaper by 1 to 3%,
info – a change exists, but the difference is not commercially significant.

Mini logic:

if(price_diff_pct >= 3 or price_diff_czk >= 300; "critical";
if(price_diff_pct >= 1; "warning"; "info"))

If your pricing policy works with margin, you can add a min_margin_pct column to the sheet. For an MVP, this is not necessary, but it is a natural extension.

Specific input: Fields own_price = 12990 and fetched_price = 12490.

Specific output: Priority critical and difference 500 Kč.

Success metric: 100% of items with a change are assigned the status critical, warning, or info.

Now we have data prepared for both humans and machines. In the next step, we will have AI create a brief, readable, and prioritized summary from it.

Step 6: Generate an AI summary of changes using the OpenAI API

What and why: You do not want to read the daily overview as a raw row export. AI serves here as a summarization layer: it pulls out the most important changes, groups risky items, and prepares a short recommendation. This is exactly the type of task where the model adds value.

Exactly how: In Make, add the HTTP > Make a request module or the official OpenAI module if you have it available. Use an endpoint compatible with the current OpenAI documentation.

Example JSON request body:

{
  "model": "gpt-4.1-mini",
  "input": "You are a pricing analyst. From the provided data, create a daily summary in Czech. Highlight critical changes, list products, competitor, old and new price, difference from our price, and a short recommendation. Data: [{"product_name":"Acer Aspire 15","competitor_name":"Alza","old_price":12990,"new_price":12490,"own_price":12990,"priority":"critical"}]"
}

It is good to keep the practical prompt brief and structured. Recommended template:

You are a pricing analyst for an e-shop.
Task: create a daily email summary in Czech.
Rules:
- first write the 3 most important findings,
- then the Critical changes section,
- then the Recommendations for today section,
- do not invent missing data,
- if an item has no history, mark it as new tracking.
Data: {{JSON_seznam_zmen}}

Example model input:

[
  {
    "product_name": "Acer Aspire 15",
    "competitor_name": "Alza",
    "old_price": 12990,
    "new_price": 12490,
    "own_price": 12990,
    "price_diff_czk": 500,
    "priority": "critical"
  }
]

Expected output:

1. Competitor Alza lowered the price of Acer Aspire 15 from CZK 12,990 to CZK 12,490.
2. Our price is now CZK 500 higher, and the item is critical.
3. Recommendation: verify the possibility of an immediate pricing response or review the inventory strategy.

Specific input: A prompt with the priority field and a JSON list of changes.

Specific output: A coherent summary in Czech ready to be inserted into an email.

Success metric: The summary is created on every run and does not contain non-existent products or prices outside the input data.

Once we have the AI output, only the final step of the workflow remains: turn everything into a daily alert and send it.

Step 7: Build and send the daily email alert

What and why: The project output must be practically usable. Not another dashboard nobody wants to open. Email is still very effective for daily operations, especially if it contains clear priorities and specific items.

Exactly how: In Make, add the Gmail > Send an Email module. Insert the date and basic statistics into the subject line.

Example subject:

AI price watcher: 6 changes, 2 critical items – 11 Mar 2026

Example HTML email body:

<h2>Daily overview of competitor price changes</h2>
<p><strong>Total monitored items:</strong> 24</p>
<p><strong>Changes since yesterday:</strong> 6</p>
<p><strong>Critical items:</strong> 2</p>
<hr>
<pre>{{ai_summary}}</pre>

Then write the result to the alert_log sheet via Google Sheets > Add a Row.

Example entry:

alert_date = 2026-03-11
total_products = 24
changed_prices = 6
critical_items = 2
email_subject = AI price watcher: 6 changes, 2 critical items – 11 Mar 2026
send_status = sent
scenario_run_id = 983421

Specific input: The ai_summary field and statistics critical_items = 2.

Specific output: A sent email and a log in the alert_log sheet.

Success metric: The email is delivered every business day and the subject and body correspond to the current data of that run.

This completes the MVP. You have automatic price collection, comparison, AI interpretation, and a daily alert. Before putting it into routine operation, however, you need to verify that it also works in less-than-ideal situations.

Recommended AI stack for implementation

Choose tools according to your budget and level of automation. Below is a direct overview of services for implementing the project.

Tool	Offer
NordVPN	Open offer
Semrush	Open offer
Make	Open offer
Hostinger	Open offer
Fiverr	Open offer
Adobe	Open offer
Canva	Open offer
Jasper	Open offer

Testing

Try Fiverr

Testing this project should be specific, not formal. Recommended procedure:

Test 1: Input loading – verify that the scenario reads exactly the number of active rows in products.
Test 2: Price extraction – for 5 products, manually compare the price on the website and the price stored in price_snapshots.
Test 3: Change calculation – modify a test product so that the price differs from yesterday and verify the percentage change.
Test 4: Priority – set one item below the 3% threshold and one above it, then check the assignment of warning and critical.
Test 5: AI summary – check that the model does not hallucinate additional items and sticks to the input data.
Test 6: Email – verify delivery, readability on mobile, and correct Czech price formatting.

A good practice for an MVP is to define simple acceptance metrics:

price loading success rate of at least 90%,
match between extracted price and website for at least 95% of tested items,
0 critical email sending errors during 5 consecutive runs,
AI summary without factual errors in all checked alerts.

Deployment

Try Adobe

For deployment into normal operation, it is enough to switch the scenario to active mode in Make. Recommended procedure:

First run the scenario manually on a small set of 10 to 20 products.
After 3 to 5 days without major errors, expand the list of monitored items.
In Make, set a notification for scenario errors.
Once a week, check products with the status fetch_status = error.
If some HTML pages frequently change structure, convert them, if possible, to a more stable feed source.

For the first production version, I recommend a daily run at a time when the sales team has not yet started dealing with operations, for example between 6:30 and 7:30. The alert will then arrive in time for morning decision-making.

Limits

Try Canva

This project has several important limitations that are worth stating openly:

HTML extraction is fragile. If a competitor changes the page structure, the selector or regular expression will stop working.
Not every website is suitable or allowed to be downloaded. Always verify the terms of the specific service and prefer an official feed or API.
Product matching may not be 100% accurate. If products do not have matching EANs, SKUs, or a clear identifier, incorrect interpretation may occur.
AI does not verify truth outside the input. If it receives bad data, it will create a well-sounding but incorrect comment.
The MVP does not address advanced pricing strategies. For example, margin after including shipping, different availability, bundle offers, or personalized prices.

That is exactly why it is appropriate to understand this system as a daily radar, not as a fully autonomous pricing engine.

FAQ

Do I need to know how to program?

Not necessarily. For a basic MVP, Make, Google Sheets, and simple module setup are enough. However, the ability to read HTML structure and understand working with fields is useful.

Can I use Airtable or a database instead of Google Sheets?

Yes, but for this guide, Google Sheets is the simplest start. If you are already running into data volume limits or multiple users, a more robust storage solution may be more suitable.

How often should I check prices?

For an MVP, once a day is enough. Higher frequency only makes sense where competitors change prices several times a day and at the same time you have a process that can react quickly.

Which OpenAI model should I choose?

For text summaries, a smaller and cheaper model is typically sufficient. The specific choice may change depending on the current API offering, so follow the official OpenAI documentation.

Can AI directly suggest a new price?

Yes, technically it can. However, I do not recommend it for an MVP without firm rules, because the model could suggest a commercially unsuitable step. It is safer to first deploy only evaluation and recommendations.

What if the competitor shows a price without VAT or with different availability?

Then the comparison is distorted. Such cases need to be either filtered out or explicitly marked as a limitation. Non-comparable prices do not belong in one metric.

Conclusion

If you go through the steps above, you will have a working MVP of a project that automatically loads competitor prices every day, stores history, calculates changes, compares them with your price, and sends a clear email with AI evaluation. The added value is not only in the monitoring itself, but mainly in the fact that the data becomes an actionable output for the person who makes pricing decisions.

Start small: 10 to 20 products, one to two competitors, a daily run, and simple priority rules. Only once this foundation is stable does it make sense to expand the system with additional sources, better product matching, or more advanced pricing recommendations. This is exactly how useful AI projects are created in practice: not as flashy demonstrations, but as a reliable working tool that saves time and improves decision-making every day.

Recommended next step

Try NordVPN

Links in the article

Sources of illustrative images

Stock photo: source

The custom illustrative image was created using the OpenAI Images API.

Service	Service description	Offer
NordVPN	VPN service for privacy protection and secure connections.	Open offer
Semrush	SEO and marketing platform for analysis and traffic growth.	Open offer
Make	Advanced visual automation for workflows and integrations.	Open offer
Hostinger	Web hosting and domains for fast website launch.	Open offer
Fiverr	Marketplace for freelancers and external specialists.	Open offer
Adobe	Creative tools for graphics, video, and digital content.	Open offer
Canva	Online design tool for graphics, presentations, and social media.	Open offer
Jasper	AI tool for marketing copy and content campaigns.	Open offer