How to Build a Price Monitoring Bot That Alerts You Before Everyone Else

Written by the RTILA Team — the engineers and product builders behind RTILA X, building web automation software since April 2020.

Knowing when a competitor drops their price—or when a supplier runs a flash sale—can mean the difference between a profitable quarter and playing catch-up. Most people still check prices manually, opening a dozen tabs every morning and squinting at numbers. There is a better way, and in this guide, we will walk through exactly how to build a price monitoring bot that does the heavy lifting for you. We will use RTILA X, the local-first automation desktop app we have been refining since our first GitHub release in April 2020. By the end, you will have a price tracker bot that extracts product prices, cleans them up, compares them against historical data, and pings you on Telegram or email when something changes. No cloud subscriptions, no credit card required to start, and everything runs on your machine.

Why Build Your Own Price Tracker Bot Instead of Using a SaaS Tool

Before we get into the steps, let us address the elephant in the room: why not just use a ready-made competitor price monitoring service? In our experience building RTILA X since 2020, we have watched hundreds of users migrate from SaaS tools for three concrete reasons. First, most SaaS price trackers charge per URL or per check interval, which gets expensive fast. Second, they run on shared cloud infrastructure that major e-commerce sites actively fingerprint and block. Third, you have zero control over how the data is processed or where it goes.

With RTILA X, your price monitoring automation runs on your own device, using your own IP address. The stealth browser engine introduced in version 8.3.0 generates a unique fingerprint per browser profile, so your price tracker bot blends in with normal traffic. You can monitor as many URLs as you want, as often as you want, and pipe the results into any system you already use—Slack, Google Sheets, a PostgreSQL database, or even a custom API endpoint. The Free Community plan handles unlimited runs on one device, so you can prototype and even run a full production workflow without spending a dime.

Step 1: Collect Your Product URLs into settings.urls

Every RTILA X project starts with a list of URLs. Open the app, create a new project, and head to settings.urls. Paste in every product page you want to monitor. These can be your own product pages, competitor listings, supplier catalogs, or all three mixed together.

When we tested this workflow on a set of 50 electronics product pages spread across three different e-commerce platforms, we learned something important: the order of your URLs matters if you plan to use Checkpoint & Resume. RTILA X tracks progress by URL index, so if a run gets interrupted mid-way, it picks up exactly where it left off. That means you can safely monitor hundreds of product pages without worrying about losing progress during a network hiccup or a system restart. The settings.max_concurrent_workers setting lets you process multiple URLs in parallel, but we recommend starting with 1 or 2 workers for price monitoring so you do not overwhelm the target server.

If you need to pull URLs dynamically—say, from a search results page that changes daily—you can use the crawl_links command to discover product URLs first, then feed them into your price extraction flow. This is where the Dataset Builder shines: it can scrape entire category pages and compile structured lists of product URLs, names, and prices in one pass.

Step 2: Extract Prices and Clean Them with Transformations

Now for the core of how to build a price monitoring bot: getting clean, comparable numbers out of messy product pages. Prices on e-commerce sites come wrapped in currency symbols, thousands separators, parenthetical notes, and sometimes hidden HTML elements. You need to strip all that noise and end up with a plain float like 29.99.

Here is the workflow we use. First, add an extract_data command and point it at the price element on your target page. Most sites have a consistent CSS selector for the price—something like .price__current or [data-testid="price"]. Use the visual selector in RTILA X to pick it; you do not need to write CSS by hand. The extracted value will look something like $29.99 or 29,99 €.

Next, apply Transformations to clean that raw text. RTILA X offers 11 transformation types, and for price monitoring you will typically chain three of them:

1. regex — to strip everything except digits, dots, and commas: [^0-9.,]
2. replace — to normalize European decimal commas into dots: replace , with .
3. cast — to convert the final string into a float for numeric comparison

After these transformations, $29.99 and 29,99 € both become 29.99. That uniformity is what makes automated comparison possible. In our testing across 12 different e-commerce platforms, this three-step transformation chain produced clean floats on the first try for 11 of them. The twelfth site had prices embedded inside a JSON blob within a <script> tag, which we handled with a json_parse transformation followed by json_path to extract the nested value. The Dataset Builder handles edge cases like this without requiring you to write custom JavaScript.

Step 3: Schedule Regular Checks with the CRON Scheduler

A one-time price check is useful. A recurring check is transformative. The Task Scheduler in RTILA X lets you run your price monitoring automation on any cadence you need: every 30 minutes, every 6 hours, daily at 8 AM, or on a custom CRON expression like 0 */4 * * * for every four hours.

When we set up competitor price monitoring for a client in the home goods space, we configured the scheduler to run every 6 hours during business days. The scheduler supports background execution even when the RTILA X desktop window is closed, which means you do not need to keep the app visible on your screen. On Windows, it runs as a system tray process; on macOS, it stays in the menu bar.

One setting worth paying attention to: settings.headless. For scheduled price checks, you can run in headless mode to reduce resource usage. But if the target site uses aggressive anti-bot detection, keep headless off and enable the Humanoid Mouse with medium sensitivity (1.0×). The cubic Bézier curve mouse movements with micro-variance make your bot’s behavior nearly indistinguishable from a human casually browsing product pages.

Step 4: Compare Prices and Detect Changes with run_script and state.variables

Extracting a price is only half the battle. The real value of a price tracker bot comes from knowing when that price changed—and by how much. RTILA X handles this through state.variables, a persistent key-value store that survives between runs.

After your extract_data command runs and transformations produce a clean float, add a run_script command with logic like this:

const productId = state.currentUrl;
const currentPrice = parseFloat(state.extractedData.price);
const previousPrice = state.variables[productId];

if (previousPrice === undefined) {
    state.variables[productId] = currentPrice;
    console.log('First run for ' + productId + ': baseline set at ' + currentPrice);
} else if (currentPrice < previousPrice) {
    const dropPercent = ((previousPrice - currentPrice) / previousPrice * 100).toFixed(1);
    state.priceDropDetected = true;
    state.dropMessage = 'Price drop on ' + productId + ': ' + previousPrice + ' → ' + currentPrice + ' (' + dropPercent + '% off)';
    state.variables[productId] = currentPrice;
} else if (currentPrice > previousPrice) {
    state.variables[productId] = currentPrice;
    // Optionally track increases too
}

This script does three things. It checks whether we have seen this product before. If not, it stores the price as a baseline. If the price dropped, it flags the drop and prepares an alert message. If the price increased, it updates the stored value silently. The state.variables object persists across runs thanks to the Checkpoint & Resume system, which saves to PocketBase on your local machine.

The run_script command also gives you access to helpers like waitForNetworkIdle and safeGoto that make navigation more reliable on slow or JavaScript-heavy product pages. If a page fails to load, the try_catch control flow command can catch the error, log it, and move on to the next URL without crashing the entire run.

Step 5: Send Alerts Through Trigger Chains

Detecting a price drop is exciting. Knowing about it five minutes later is what makes money. RTILA X Trigger Chains execute immediately after your project finishes, and they support over 40 integrations out of the box.

For a Telegram alert, add a Trigger Chain step with the send_email or webhook_out type. Telegram’s Bot API accepts a simple HTTP POST, so you can use the rest_api trigger type with your bot token and chat ID. The message body pulls from state.dropMessage, the variable we set in the previous step. Here is what the Trigger Chain configuration looks like in practice:

• Type: rest_api
• Method: POST
• URL: https://api.telegram.org/bot{telegram_bot_token}/sendMessage
• Body: {"chat_id": "{telegram_chat_id}", "text": "{dropMessage}"}

Variables in RTILA X use single curly braces—{variable_name}—so the trigger chain automatically substitutes the actual drop message before sending. You can add multiple trigger steps in sequence: for example, send a Telegram alert, then log the drop to a Google Sheet via the google_sheets trigger, then update a Slack channel via slack_webhook. The parallel trigger type lets you fire all three simultaneously if latency matters.

For email alerts, the send_email trigger type supports SMTP configuration with your own email provider. In our experience, email works best for daily digest-style alerts, while Telegram or Slack is better for real-time price drop notifications that you want to act on immediately.

Real-World Scenario: Monitoring 200 Competitor SKUs

Let us ground this in a concrete example. One of our users runs a mid-sized electronics retailer with about 200 SKUs that overlap with three major competitors. Before RTILA X, they had a VA manually check prices every Monday morning, which took roughly four hours and cost about $80 per week in labor. Human error meant occasional misses—a competitor would drop a price on Tuesday, and they would not catch it until the following Monday.

They rebuilt this workflow in RTILA X in a single afternoon. The project uses 200 product URLs in settings.urls, a Dataset Builder configuration with item selectors for product name and price, the three-step transformation chain we described above, and a run_script block that compares current prices against stored baselines. The scheduler runs every 4 hours, Monday through Saturday. Trigger Chains send real-time Telegram alerts for any drop over 5% and compile a daily summary email with all price movements.

The result: they now catch competitor price changes within four hours instead of seven days, and the entire system runs unattended on a spare office desktop. Total cost: zero on the Free Community plan, since 200 URLs and unlimited runs fit comfortably within the free tier. They later upgraded to the Business 1 Device plan at $9/month to unlock the Standalone Bot Export feature, which lets them package the project as a portable executable for deployment on a dedicated monitoring machine.

Sources and Verification

We build and test every feature we write about on real websites, every week. RTILA X has been publicly available since our first GitHub release on April 10, 2020. Our AppSumo launch in 2021 earned 116 reviews at a 4.7/5 rating. Our Product Hunt launch in 2023 earned a 5/5 rating. We maintain a 5/5 rating on Trustpilot. We exhibited at GITEX Africa 2026 in Marrakech. You can verify these claims at the following links:

• AppSumo reviews: https://appsumo.com/products/marketplace-rtila-growth-hacking-marketing-automation-software/reviews/
• Trustpilot: https://www.trustpilot.com/review/rtila.com
• Product Hunt: https://www.producthunt.com/products/rtila-studio
• GitHub releases: https://github.com/rtila-corporation/rtila-releases/releases

Conclusion: Your Price Monitoring Bot Is Ready to Run

Learning how to build a price monitoring bot is one of those skills that pays for itself the first time you catch a competitor undercutting you—or a supplier running a 40% off clearance sale you would have otherwise missed. With RTILA X, you get a local-first automation platform that handles the full pipeline: URL collection, data extraction, transformations, scheduled execution, stateful comparison, and multi-channel alerts. No cloud lock-in, no per-URL pricing, and a free tier generous enough to run production workloads.

The workflow we walked through today—collect URLs, extract and clean prices, schedule recurring checks, compare against history, and alert on changes—works the same whether you are tracking 10 products or 10,000. The Checkpoint & Resume system means you never lose progress, and Trigger Chains make sure you hear about price drops the moment they happen, not days later.

Ready to build yours? Download RTILA X for Windows, macOS, or Linux. The Free Community plan requires no credit card and includes unlimited runs. If you need multi-device support, Standalone Bot Export, or white-label rights, paid plans start at $9/month with a 60-day money-back guarantee.

---

FAQ

Do I need to know how to code to build a price monitoring bot with RTILA X?

No, you do not need coding experience for most of the workflow. The visual selector picks page elements for you, the Dataset Builder handles extraction without writing selectors, and Transformations clean up data through a point-and-click interface. The run_script step for price comparison does involve a small amount of JavaScript, but the template we provided above works as-is—you only need to copy and paste it. If you want custom logic beyond what we covered, the run_script command supports full JavaScript with access to all the helper functions listed in the RTILA X documentation.

How often can I run my price tracker bot?

As often as you want. The Task Scheduler supports intervals down to the minute, custom CRON expressions, and multiple schedules per project. The only practical limit is the target website’s tolerance for automated visits. We recommend starting with 4-hour or 6-hour intervals for competitor price monitoring and adjusting based on how the site responds. The Humanoid Mouse and browser profile isolation features help your bot blend in with normal traffic patterns.

Can RTILA X handle websites that require login for pricing?

Yes. RTILA X supports browser profiles with isolated cookies, so you can log into a supplier portal or wholesale site once, save the profile, and reuse that authenticated session for every scheduled run. The set_cookie command lets you inject session tokens programmatically, and the get_storage_state command can export and re-import authentication state across profiles. This is especially useful for B2B price monitoring where suppliers gate pricing behind login walls.

---

---

Written by the RTILA X team. We build and test every feature we write about on real websites, every week. Our automation engine has been in active development since April 2020, and we use it daily to monitor prices, extract data, and automate repetitive browser tasks across hundreds of real-world scenarios.

RTILA X automates actions you could perform manually. Always review each platform’s Terms of Service and applicable data-privacy laws before automating.