Features

Find Monitor Text in Source: Detect Keywords Hidden in a Page's HTML

Keyword monitoring usually watches the visible text on a page — the words you can actually read. But sometimes the value you care about lives in the page's HTML source instead: inside a hidden element, a data- attribute, an inline script, or JSON that the page has not rendered on screen yet. When that happens, ordinary keyword detection never fires, because the word is technically not "visible."

The Find monitor text in source option solves this. On the Detect Keyword tab, enable it and Auto Refresh will search the complete HTML source — including hidden elements and scripts — instead of only the visible text.

Auto Refresh

English

Running

Time Interval

Refresh List

Detect Keyword

Play sound on keyword found / not found

Notify the user when a keyword is found / not found

Find monitor text in source

How to enable Find monitor text in source

Open the Auto Refresh extension and switch to the Detect Keyword tab.
Enter the keyword (or keywords) you want the extension to watch for.
Tick Find monitor text in source.
Click Save. From the next reload onward, Auto Refresh scans the raw HTML source for your keyword instead of only the visible on-screen text.

When to use it — and when not to

Use it when the value is in the markup, not on screen: a status held in a hidden <div>, a stock or price stored in a data- attribute, or a flag written into an inline script or JSON blob.
It is mainly for developers. This method reads the full page source, so it is more technical than standard visible-text matching.
It is slower. Scanning the entire HTML source takes more work than scanning visible text, so expect detection to be a little heavier on each reload.
Watch for false positives. Because it also reads hidden elements and scripts, a keyword that appears in background markup can trigger a match even though nothing changed on the visible page.
Enable it only if standard matching is not enough. If normal visible-text keyword detection already catches what you need, leave this off for faster, cleaner results.

Visible-text matching vs. source matching

By default, keyword detection looks at the rendered page — the text a human would actually see once the browser has drawn everything. That is the right choice almost all of the time: it is fast, and it matches your intuition about what is "on the page." Find monitor text in source works one layer lower. Instead of the rendered result, it reads the raw HTML the server sent — every tag, attribute, comment, and inline script, whether or not any of it is shown. So a word wrapped in a display:none element, sitting in a title attribute, or written into a <script> block is invisible to normal detection but perfectly visible to source detection.

A quick example

Imagine a product page that shows "Out of stock" to shoppers, but the developers left the real state in the markup as data-availability="in_stock" before the UI updates. Standard detection would keep matching the visible "Out of stock" text. Turn on Find monitor text in source and set your keyword to in_stock, and Auto Refresh can catch the change the moment it appears in the HTML — often a beat before the visible page catches up. The same trick works for status flags, hidden error messages, and values that a page stores in the source but renders later with JavaScript.

Tips to keep results clean

Pick a keyword that is as specific as possible. Short or common words are far more likely to appear somewhere in the markup by accident.
If you start getting matches that do not reflect a real change on the page, that is the classic false-positive from background markup — tighten the keyword or switch the rule back to visible-text detection.
Keep it enabled only on the rules that truly need it. Leaving it on everywhere makes every check slower for no benefit.

Find monitor text in source is the option to reach for when the thing you are monitoring never actually renders on the page. Turn it on for those specific rules, keep it off everywhere else, and Auto Refresh can catch changes buried in the HTML that visible-text detection would quietly miss.