Urlwatch setup on Windows 11 for monitoring website changes

Urlwatch on Windows 11 is a self-hosted website change monitor: install it with Python and pip, define pages in YAML, run it manually to check the results, then use Windows Task Scheduler to run it on a recurring schedule. Urlwatch retrieves each job, applies any configured filters, compares the result with the previous run, and reports detected changes. It only checks while the computer is available to run the scheduled task.

This guide uses a normal HTTP URL job first, because it is the simplest option. If the page’s meaningful content appears only after JavaScript runs, use a browser job instead. The project recommends running checks no more often than every 30 minutes; follow the monitored site’s terms and choose an interval appropriate to how quickly you need to know about changes. Urlwatch quick start and overview

1. Install Urlwatch on Windows 11

Open a terminal, such as PowerShell or Windows Terminal.
Install or upgrade Urlwatch using Python’s module form of pip:

python -m pip install --upgrade urlwatch

Verify that the command is available and prints a version:

urlwatch --version

The official installation instructions recommend this pip command and checking that urlwatch is on your PATH. If python is not recognized, resolve your Python installation or command-path issue before continuing. If Python works but urlwatch is not recognized, use the interpreter’s Scripts directory or invoke the installed module with the same Python interpreter as a diagnostic. Exact Python installer screens and PATH behavior depend on the local setup. Urlwatch installation documentation

Run Urlwatch once to initialize its local state or migrate existing state, then create a first job:

urlwatch
urlwatch --edit

The --edit command opens the job file, urls.yaml, through the configured editor and checks the edited configuration before activating it. Global settings and reporters are configured separately with urlwatch --edit-config, which edits urlwatch.yaml. If the editor does not open, inspect the command output and configure an editor in the environment used to run Urlwatch. Quick start

2. Add a page to monitor

Start with a page whose relevant text is present in the response returned by the web server. Add this to urls.yaml using urlwatch --edit:

name: Example page
url: https://example.com/

Save and close the editor, then run Urlwatch manually:

urlwatch

The first run establishes a baseline; Urlwatch needs a prior result to compare against. Run it again after the page has changed to confirm the difference is useful. If there are multiple jobs, separate each YAML job with a line containing only ---:

name: Example page
url: https://example.com/
---
name: Project announcements
url: https://example.org/announcements

Keep names descriptive so change reports are easy to identify. You can list configured jobs with urlwatch --list. Each job has one defining key: url for an ordinary HTTP retrieval, navigate for a browser-rendered page, or command for a shell command. Urlwatch job types and job options

3. Reduce noisy changes with filters

Pages often include content that changes more frequently than the item you care about: timestamps, rotating announcements, navigation, or other surrounding markup. Urlwatch filters let you transform the retrieved result before comparison. The documented filter types include CSS and XPath extraction, HTML-to-text conversion, JSON formatting, and text matching. Filter names and syntax depend on the filter you choose; use the installed version’s documentation and test a filter against the actual page output before relying on it.

A practical tuning loop is:

Run the job without filters and inspect what Urlwatch retrieves.
Choose a filter that retains the content relevant to your alert.
Run again and make sure the filtered result still includes the content you need.
When available, use Urlwatch’s filter test options, such as --test-filter, to inspect how a filter transforms the result.

Filtering too broadly can hide a real change; filtering too narrowly can leave noisy diffs. Revisit the result when the website changes its markup. The jobs documentation describes per-job filters and related options.

4. Choose URL retrieval or browser rendering

An ordinary URL job fetches the server response. It is usually the right starting point and avoids the additional browser setup and resource use. A browser job uses Playwright to load a page that needs JavaScript to render the content being monitored. Use it only when an ordinary URL job does not return the content you need.

To configure a browser job, install the optional Playwright dependency and its browser, following the Urlwatch and Playwright instructions for your environment. A minimal browser job is:

name: JavaScript-rendered page
navigate: https://example.com/interactive-page

Browser jobs also support settings such as the browser to use, navigation wait condition, a selector to wait for, and a user agent. Use a selector wait when the desired content appears after initial navigation; avoid assuming a fixed delay is sufficient for every page. Urlwatch documents load, domcontentloaded, networkidle, and commit as wait conditions. The documentation discourages networkidle in general, so prefer a meaningful selector or another appropriate condition when possible. Browser jobs use substantially more resources than URL jobs. In some cases, the page’s underlying API response can be monitored directly with a faster URL job. Browser job options · Advanced topics

5. Schedule Urlwatch with Windows Task Scheduler

Urlwatch runs when launched; its monitoring interval is determined by how often it runs. On Windows, the project recommends Task Scheduler because cron is not installed by default. Microsoft documents Task Scheduler and the schtasks command for scheduling programs on Windows 11. Microsoft Task Scheduler overview · Microsoft schtasks create reference

First make sure urlwatch runs successfully from a terminal under the Windows account that will own the task.
Open Task Scheduler and create a task with a recurring time-based trigger. Choose a daily or repeating schedule that meets your needs and the site’s request policies. Urlwatch recommends no more frequently than every 30 minutes.
Set the action to start a program. For the program, use the full path to the Python executable that has Urlwatch installed. Set the arguments to -m urlwatch. This uses Python’s module invocation and avoids relying on the scheduled task finding the Urlwatch launcher through a different PATH.
If you instead use the Urlwatch launcher, enter its full path and confirm it works under the same account. Do not assume an interactive terminal’s PATH or current directory will be available to the scheduled task.
Save the task, use Task Scheduler’s run action to launch it immediately, and inspect the task’s last-run result and any Urlwatch output or reporter notification.

Task Scheduler’s trigger controls when the command runs; Urlwatch does not keep checking between launches. Keep the computer available and connected at the scheduled time. A task cannot perform a check while the PC is powered off, and this guide makes no assumption about whether a sleeping PC will wake for a particular task configuration. Confirm actual behavior on the machine and task settings you use.

The full Python executable path varies by installation. To identify the interpreter used by your working terminal, run:

python -c "import sys; print(sys.executable)"

Use the printed path as the Task Scheduler program, with -m urlwatch as its argument. This scheduling command construction is operational guidance based on Python module invocation and Urlwatch’s command-line entry point; it is not a Windows-specific recipe quoted from the Urlwatch documentation.

6. Configure and verify notifications

By default, Urlwatch writes its report to standard output. Optional reporters include email/SMTP and services such as Slack, Discord, Telegram, Matrix, and Pushover. Reporters may require extra dependencies, credentials, and service-specific configuration. Configure the reporter under report in urlwatch.yaml using urlwatch --edit-config. Check the documentation for the selected reporter’s current configuration keys rather than copying settings for a different service. Urlwatch handbook

Test the reporter independently before relying on the scheduled task:

urlwatch --test-reporter REPORTER_NAME

Replace REPORTER_NAME with the reporter name supported by your installed version. For diagnostic output, run Urlwatch with --verbose. A successful reporter test confirms only that interactive reporter test; separately run the scheduled task and verify its last-run result and that the alert arrives in the intended destination.

7. Windows-specific troubleshooting

Symptom	Likely cause	What to check or change
`python` is not recognized	Python is not available under that command in this terminal.	Resolve the Python installation or command path, then retry the pip install command with the interpreter you intend Urlwatch to use.
`urlwatch` is not recognized	The Urlwatch launcher is not on this terminal’s PATH, or installation used a different Python environment.	Confirm the installation with the same Python interpreter. For Task Scheduler, use that interpreter’s full path and `-m urlwatch`.
`UnicodeDecodeError` while reading UTF-8 YAML	Python on Windows may not be using UTF-8 mode for the process.	For Python 3.7 and newer, set `PYTHONUTF8=1` for the terminal session or appropriate user/system environment, then retry. Ensure the scheduled process receives it too. Urlwatch handbook: Windows UTF-8 mode
Scheduled task does not find Urlwatch or uses the wrong configuration	The task runs with a different account, PATH, environment, or working context than the interactive terminal.	Use the intended Python executable’s absolute path, verify Urlwatch is installed for that interpreter, and run the task under the expected account. Inspect the task result and output.
Task runs but no useful change is reported	The site may return a different response to a simple fetch, the job may be new, or the filter may remove relevant content.	Run manually, inspect the retrieved/filtered result, confirm the baseline, and try a browser job only if required JavaScript content is missing.
Dynamic page content is absent	A URL job reads the server response without executing page JavaScript.	Try a browser job with Playwright installed, or identify whether the content is available from an underlying API endpoint that can be fetched directly.
Reporter test fails or alert never arrives	Reporter settings, dependencies, credentials, or destination configuration may be incorrect; scheduled execution may also have a different environment.	Test the reporter interactively, use `--verbose`, check the reporter’s required configuration, then verify the scheduled run separately.
Frequent or noisy notifications	The monitored page includes volatile content, or the schedule checks more often than needed.	Filter to the meaningful content, validate that the filter preserves changes you care about, and choose a schedule no more frequent than the project’s 30-minute recommendation.

Urlwatch options and features can change across versions. If an option behaves differently, check the installed version’s urlwatch --help and urlwatch --features output and the documentation for that release.

8. Performance, reliability, and cost

Performance: ordinary URL retrieval is the lighter starting point. Browser jobs need Playwright and browser installation, and the Urlwatch documentation says they use substantially more resources. Avoid browser rendering when a URL job or relevant API response supplies the required content.
Reliability: verify the first manual run, subsequent comparison, reporter test, and scheduled run independently. Task Scheduler invokes Urlwatch at configured times; it does not provide continuous monitoring between runs. The PC and network need to be available for checks to happen.
Request frequency: the project recommends at least 30 minutes between checks. A daily run may be enough for slow-changing pages. Your chosen cadence should account for the site’s terms and the urgency of changes.
Cost: Urlwatch is installed as a Python package. The setup described here does not establish the cost of optional third-party notification services or the computer running the task; check those providers’ terms if you choose them.

Or skip the browser setup

If your goal is to capture a visual snapshot of a page rather than keep a self-hosted text-change history, ScreenshotNeo is a website screenshot API and MCP server for developers. A single GET request returns a screenshot or PDF. See the ScreenshotNeo API documentation.

cURL:

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,
)
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(`ScreenshotNeo request failed: ${res.status}`);
const image = Buffer.from(await res.arrayBuffer());
await import('node:fs/promises').then(fs => fs.writeFile('shot.webp', image));

ScreenshotNeo removes cookie banners, newsletter popups, and chat widgets before the shot. Bot checks, blank pages, and failed loads are never billed. Its MCP server lets AI agents take screenshots. The free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000 shots. Sign up for 1,000 free screenshots a month, with no card.

FAQ

Does Urlwatch keep checking when Windows is shut down?

No. Urlwatch runs when launched, so it needs the computer available for the scheduled run.

Can I monitor more than one page?

Yes. Add one job per page to urls.yaml, separating jobs with a line containing ---.

Will Urlwatch notify me every time it runs?

Its reporters are used to report changes according to their configuration. The default reporter writes to standard output; configure and test an optional reporter if you need alerts elsewhere.

Urlwatch supports job options such as cookies, but authenticated pages can require site-specific setup. Consult the current advanced documentation and ensure your monitoring complies with the site’s terms.

Is Urlwatch a visual screenshot monitor?

Urlwatch monitors retrieved or rendered job output for changes. For visual page captures, use a screenshot API such as ScreenshotNeo.