Urlwatch on macOS: Install and Schedule Website Checks

To monitor websites on macOS with urlwatch, install it with Homebrew, configure jobs with urlwatch --edit, run a manual check, then schedule it with cron. urlwatch fetches or runs each configured job, applies any filters, compares the result with the previous output, and reports changes. This guide uses cron, the scheduling method covered by urlwatch’s documentation.

1. Install urlwatch with Homebrew

Install Homebrew first if it is not already available, then run:

brew install urlwatch

The official Homebrew formula is the macOS installation route. Package versions and macOS bottle details can change, so check the current urlwatch formula if installation behaves differently on your Mac.

Initialize urlwatch’s data and configuration by running it once:

urlwatch

Then open the job list:

urlwatch --edit

This edits urls.yaml, where you define pages, commands, and optional filters. To open global settings, including reporter configuration, run:

urlwatch --edit-config

2. Configure your first website check

In urls.yaml, define the page or pages you want urlwatch to monitor. The exact YAML fields depend on the job type and options you need; use the documentation’s examples as the schema reference. A basic URL job retrieves a page without rendering it in a browser. Start with that when the content is present in the returned page.

urlwatch supports three useful job types:

• url: retrieves a URL directly. Prefer this for pages whose relevant content is available from the normal request.
• navigate: renders a page in a headless browser. Use it when client-side JavaScript is needed to produce the content you want to track. Browser jobs use more resources.
• command: runs a shell command and monitors its output.

After editing, run urlwatch manually. Check that each job reaches the intended content and that the output is useful before putting it on a schedule. A first run establishes the result for comparison; later runs report differences against saved output.

3. Reduce noisy changes with filters

A whole-page comparison can report changes that do not matter to you. Filters let you select or normalize the content to compare. The documented filter options include CSS and XPath selection, text, JSON, PDF, and other filters. Filters can be chained.

For example, if only a pricing block matters, use a CSS or XPath selection filter to focus on that part of the page. If the page contains changing timestamps or unrelated text, use an appropriate filter to discard or normalize those parts. Confirm the resulting output with a manual run: a filter that selects the wrong element can make a job appear unchanged or empty.

See the urlwatch introduction for the supported job fields, filter syntax, and examples. Its configuration schema is the source of truth when adapting a job.

4. Run a check and choose notifications

Run the command manually from a terminal:

urlwatch

By default, inspect the terminal output to see whether the jobs ran and whether differences were found. urlwatch can also report changes through configured reporters, including email and third-party services. Set those destinations in the global configuration with urlwatch --edit-config; merely scheduling urlwatch does not configure or guarantee delivery to an external destination.

The project describes change notices as including the changed URL and a unified diff. Keep a terminal run in your setup checklist even when using a reporter, so you can distinguish a job or configuration problem from a notification delivery problem.

5. Schedule urlwatch with cron

Open your crontab editor:

crontab -e

Add a schedule such as this example, which runs every 30 minutes:

*/30 * * * * urlwatch

The five schedule fields are minute, hour, day of month, month, and day of week. In */30 * * * *, the minute field means every 30 minutes. urlwatch’s guide recommends not checking more often than every 30 minutes.

Some cron environments have a smaller PATH than an interactive terminal. If cron cannot find urlwatch, find the executable path in your interactive shell with:

command -v urlwatch

Use that full path in the crontab entry if needed, for example:

*/30 * * * * /path/to/urlwatch

Replace /path/to/urlwatch with the actual path printed on your Mac. Cron runs under its own environment, so validate the command and any required configuration as the same user who owns the crontab.

Choose the right monitoring setup

Decision	Choose this when	Trade-off
URL job or browser navigation	Use a URL job if the fetched page already contains the content; use navigation if JavaScript must render it.	Browser navigation consumes more resources, so reserve it for pages that need rendering.
Whole page or filtered content	Monitor the whole result for broad change awareness; filter to an element or content type when unrelated changes are noisy.	A narrow filter reduces noise but can miss changes outside its selection.
Terminal or reporter	Use terminal output for local inspection; configure a reporter for a destination where you need change notices.	External delivery requires reporter setup and its own configuration.
Check frequency	Choose a cron interval appropriate to how quickly you need to notice a change.	The project recommends intervals of at least 30 minutes.

Performance, reliability, and cost

Direct URL retrieval is the lighter choice when it returns the content you need; browser navigation is more resource-intensive. Filtering can reduce irrelevant differences and make reports easier to act on. Schedule at an interval that meets your monitoring need while respecting the project’s recommendation not to run more often than every 30 minutes.

urlwatch is software installed through Homebrew. The research sources do not establish a price for a hosted monitoring service, a service-level guarantee, or a fixed resource requirement. Your checks depend on the target site’s availability and the environment running the scheduled command. Review manual output and configure an appropriate reporter if you need changes delivered somewhere beyond the terminal.

Common problems and fixes

Symptom	Likely cause	What to do
brew install urlwatch cannot find a compatible package or bottle	Homebrew formula details or macOS support may have changed.	Check the current formula page for the supported installation details, then follow its current instructions.
A scheduled run does nothing or reports that urlwatch was not found	Cron may not inherit your interactive shell’s PATH.	Run command -v urlwatch in your terminal and use the resulting full path in the crontab.
A job reports changes on every run	The page may include frequently changing content, or the comparison includes more than the part you care about.	Inspect the job output, then use a suitable CSS, XPath, text, or other filter to focus or normalize the compared content.
A job produces empty or unexpected output	The retrieval method may not expose the desired content, or a filter may select the wrong content.	Run urlwatch manually and inspect the processed result. Try browser navigation if JavaScript rendering is required, or revise the filter using the documented syntax.
No email or third-party notification arrives	The external reporter destination may not be configured, or its settings may be wrong.	Open urlwatch --edit-config, review reporter settings, and run a manual check while inspecting terminal output.
Checks run more often than intended	The cron expression may not match the intended interval.	Review the five cron fields and use */30 * * * * for the documented 30-minute example.

Or skip the browser setup

For a one-off screenshot of a page, ScreenshotNeo provides a website screenshot API: one GET request returns an image or PDF. It can accept cookie banners and remove known consent platforms, newsletter popups, and chat widgets before capture. Bot checks, blank pages, and failed loads are not billed; responses include page-verdict and billing headers. Its MCP server gives AI agents screenshot, page-info, and PDF capture tools.

Here is a complete cURL request. Replace YOUR_API_KEY with your key:

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webp

Python:

import requests

r = requests.get(
    "https://api.screenshotneo.com/v1/shot",
    params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"},
    timeout=90,
)
r.raise_for_status()
open("shot.webp", "wb").write(r.content)

Node.js:

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);
if (!res.ok) throw new Error(`Screenshot request failed: ${res.status}`);
await import('node:fs/promises').then(fs => fs.writeFile('shot.webp', Buffer.from(await res.arrayBuffer())));

ScreenshotNeo supports PNG, JPEG, WebP, and PDF, with options including full-page capture, element selection, device presets, viewport sizing, waits, cookies, headers, custom CSS and JavaScript, caching, and bulk capture. It is for capturing a page, while urlwatch is for recurring change checks.

Read the ScreenshotNeo API documentation for request options. The free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000. Sign up for free and capture your first screenshot.

FAQ

Does urlwatch monitor page changes continuously?

No. It checks when you run it; cron supplies the recurring schedule.

Can it monitor more than web pages?

Yes. Documented jobs also include shell commands, and browser navigation is available for JavaScript-dependent pages.

Will a filter notify me about changes outside the selected content?

No. A filter narrows the processed result, so changes excluded by that filter will not appear in the comparison.

Where can I confirm the current install details?

Check the official Homebrew formula for current package and macOS information.

Sources

• urlwatch introduction for setup, job types, filters, reporters, and cron guidance.
• Homebrew urlwatch formula for the installation route and current formula details.
• thp/urlwatch on GitHub for the project’s purpose and change-report overview.